From d0ef2af55766cecaa28ff61d14e3fd48668f3e6a Mon Sep 17 00:00:00 2001
From: mumana <mumana@atesa.tfs.local>
Date: Wed, 13 Jun 2018 16:26:15 +0000
Subject: [PATCH] git-tfs-id: [http://192.168.1.10:8080/tfs/AyA]$/SINORT;C43

---
 .../AYA.SlnSynor.WCF/SinortCatalogos.svc.cs   |     8 +
 .../AYA.SlnSynor/AYA.SlnSinort.csproj         |     6 +-
 .../Controllers/BaseController.cs             |     6 +
 .../Controllers/HomeController.cs             |    14 -
 .../Matenimimento/AplicacionAPIController.cs  |    51 -
 .../Matenimimento/EmisorAPIController.cs      |    52 -
 .../MantenimientoAPIController.cs             |    35 -
 .../AYA.SlnSynor/Views/Shared/_Layout.cshtml  |   168 +-
 .../AYA.SlnSinortModel.DAL.csproj             |     1 +
 .../Sinort/PantallasDAL.cs                    |    31 +
 .../AYA.SlnSinortModel.csproj                 |     1 +
 .../AYA.SlnSynorModel/Sinort/Pantallas.cs     |    36 +
 .../AYA.SlnSynorModel/Sinort/SinortContex.cs  |   375 +
 .../Atesa.Utilitarios.csproj                  |     4 +
 .../Atesa.Utilitarios/packages.config         |     1 +
 .../log4net.2.0.8/lib/net20-full/log4net.dll  |   Bin 0 -> 278528 bytes
 .../log4net.2.0.8/lib/net20-full/log4net.xml  | 31421 +++++++++++++++
 .../lib/net35-client/log4net.dll              |   Bin 0 -> 282624 bytes
 .../lib/net35-client/log4net.xml              | 32259 +++++++++++++++
 .../log4net.2.0.8/lib/net35-full/log4net.dll  |   Bin 0 -> 286720 bytes
 .../log4net.2.0.8/lib/net35-full/log4net.xml  | 32464 ++++++++++++++++
 .../lib/net40-client/log4net.dll              |   Bin 0 -> 274944 bytes
 .../lib/net40-client/log4net.xml              | 32259 +++++++++++++++
 .../log4net.2.0.8/lib/net40-full/log4net.dll  |   Bin 0 -> 275968 bytes
 .../log4net.2.0.8/lib/net40-full/log4net.xml  | 32464 ++++++++++++++++
 .../log4net.2.0.8/lib/net45-full/log4net.dll  |   Bin 0 -> 276480 bytes
 .../log4net.2.0.8/lib/net45-full/log4net.xml  | 32464 ++++++++++++++++
 .../lib/netstandard1.3/log4net.dll            |   Bin 0 -> 221184 bytes
 .../log4net.2.0.8/log4net.2.0.8.nupkg         |   Bin 0 -> 1750988 bytes
 29 files changed, 193884 insertions(+), 236 deletions(-)
 delete mode 100644 AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/AplicacionAPIController.cs
 delete mode 100644 AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/EmisorAPIController.cs
 delete mode 100644 AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/MantenimientoAPIController.cs
 create mode 100644 AYA.SlnSynor/AYA.SlnSynorModel.DAL/Sinort/PantallasDAL.cs
 create mode 100644 AYA.SlnSynor/AYA.SlnSynorModel/Sinort/Pantallas.cs
 create mode 100644 AYA.SlnSynor/AYA.SlnSynorModel/Sinort/SinortContex.cs
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net20-full/log4net.dll
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net20-full/log4net.xml
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-client/log4net.dll
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-client/log4net.xml
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-full/log4net.dll
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-full/log4net.xml
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-client/log4net.dll
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-client/log4net.xml
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-full/log4net.dll
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-full/log4net.xml
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net45-full/log4net.dll
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/net45-full/log4net.xml
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/lib/netstandard1.3/log4net.dll
 create mode 100644 AYA.SlnSynor/packages/log4net.2.0.8/log4net.2.0.8.nupkg

diff --git a/AYA.SlnSynor/AYA.SlnSynor.WCF/SinortCatalogos.svc.cs b/AYA.SlnSynor/AYA.SlnSynor.WCF/SinortCatalogos.svc.cs
index 7cc9da1f9..8835d3dd6 100644
--- a/AYA.SlnSynor/AYA.SlnSynor.WCF/SinortCatalogos.svc.cs
+++ b/AYA.SlnSynor/AYA.SlnSynor.WCF/SinortCatalogos.svc.cs
@@ -128,5 +128,13 @@ namespace AYA.SlnSinort.WCF
             return respuesta;
         }
         #endregion
+
+        #region Pantallas
+        public List<Pantallas> ObtenerPantallas(Usuario model)
+        {
+            return new PantallasDAL().ObtenerPantallas(model);
+        }
+        #endregion
+    
     }
 }
diff --git a/AYA.SlnSynor/AYA.SlnSynor/AYA.SlnSinort.csproj b/AYA.SlnSynor/AYA.SlnSynor/AYA.SlnSinort.csproj
index 77cd05d54..bf0fc7b3b 100644
--- a/AYA.SlnSynor/AYA.SlnSynor/AYA.SlnSinort.csproj
+++ b/AYA.SlnSynor/AYA.SlnSynor/AYA.SlnSinort.csproj
@@ -182,9 +182,6 @@
     <Compile Include="App_Start\RouteConfig.cs" />
     <Compile Include="App_Start\Startup.Auth.cs" />
     <Compile Include="App_Start\WebApiConfig.cs" />
-    <Compile Include="ControllersWebApi\Matenimimento\AplicacionAPIController.cs" />
-    <Compile Include="ControllersWebApi\Matenimimento\EmisorAPIController.cs" />
-    <Compile Include="ControllersWebApi\Matenimimento\MantenimientoAPIController.cs" />
     <Compile Include="Controllers\AccountController.cs" />
     <Compile Include="Controllers\BaseController.cs" />
     <Compile Include="Controllers\Catalogos\CatalogosController.cs" />
@@ -7734,6 +7731,9 @@
       <Name>AYA.SlnSinortModel</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <WCFMetadata Include="Service References\" />
+  </ItemGroup>
   <PropertyGroup>
     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
diff --git a/AYA.SlnSynor/AYA.SlnSynor/Controllers/BaseController.cs b/AYA.SlnSynor/AYA.SlnSynor/Controllers/BaseController.cs
index 0c6ca4056..4797565f0 100644
--- a/AYA.SlnSynor/AYA.SlnSynor/Controllers/BaseController.cs
+++ b/AYA.SlnSynor/AYA.SlnSynor/Controllers/BaseController.cs
@@ -4,6 +4,8 @@ using System.Linq;
 using System.Web;
 using System.Web.Mvc;
 using System.Configuration;
+using AYA.SlnSinortModel.Sinort;
+using AYA.SlnSinortModel.DAL.Sinort;
 
 namespace AYA.SlnSinort.Controllers
 {
@@ -17,6 +19,10 @@ namespace AYA.SlnSinort.Controllers
 
             ViewBag.SinortWCF = SinortWCF;
             ViewBag.SinortCatalogosWCF = SinortCatalogosWCF;
+
+            var ListaPantallas = new PantallasDAL().ObtenerPantallas(null);
+
+            ViewBag.ListaPantallas = ListaPantallas;
         }
     }
 }
\ No newline at end of file
diff --git a/AYA.SlnSynor/AYA.SlnSynor/Controllers/HomeController.cs b/AYA.SlnSynor/AYA.SlnSynor/Controllers/HomeController.cs
index 218f4f27f..8d4a96d07 100644
--- a/AYA.SlnSynor/AYA.SlnSynor/Controllers/HomeController.cs
+++ b/AYA.SlnSynor/AYA.SlnSynor/Controllers/HomeController.cs
@@ -14,20 +14,6 @@ namespace AYA.SlnSinort.Controllers
             return View();
         }
 
-        public ActionResult About()
-        {
-            ViewBag.Message = "Your application description page.";
-
-            return View();
-        }
-
-        public ActionResult Contact()
-        {
-            ViewBag.Message = "Your contact page.";
-
-            return View();
-        }
-
         public ActionResult Normativa_Reglamentacion_Tecnica()
         {
             return View();
diff --git a/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/AplicacionAPIController.cs b/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/AplicacionAPIController.cs
deleted file mode 100644
index 7e223a3a6..000000000
--- a/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/AplicacionAPIController.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-using AYA.SlnSinortModel.DAL.Sinort;
-using AYA.SlnSinortModel.Entidades;
-using AYA.SlnSinortModel.Sinort;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Web;
-using System.Web.Http;
-
-
-namespace AYA.SlnSinort.ControllersWebApi.Matenimimento
-{
-    public class AplicacionAPIController : ApiController
-    {
-        #region Aplicacion
-        [HttpGet]
-        public List<Aplicacion> ObtenerAplicacion()
-        {
-            List<Aplicacion> respuesta = null;
-            try
-            {
-                respuesta = new AplicacionDAL().ObtenerAplicacion();
-
-            }
-            catch (Exception ex)
-            {
-                throw;
-            }
-            return respuesta;
-        }
-
-        [HttpPost]
-        public BaseJson InsertarActualizarAplicacion(Aplicacion model)
-        {
-            BaseJson respuesta = new BaseJson();
-            try
-            {
-                respuesta = new AplicacionDAL().InsertarActualizarAplicacion(model);
-            }
-            catch (Exception ex)
-            {
-
-                throw;
-            }
-            return respuesta;
-        }
-
-
-        #endregion
-    }
-}
\ No newline at end of file
diff --git a/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/EmisorAPIController.cs b/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/EmisorAPIController.cs
deleted file mode 100644
index b5163c004..000000000
--- a/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/EmisorAPIController.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using AYA.SlnSinortModel.DAL.Sinort;
-using AYA.SlnSinortModel.Entidades;
-using AYA.SlnSinortModel.Sinort;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Web;
-using System.Web.Http;
-
-namespace AYA.SlnSinort.ControllersWebApi.Matenimimento
-{
-    public class EmisorAPIController : ApiController
-    {
-        #region Emisor
-        [HttpGet]
-        public List<Emisor> ObtenerEmisor()
-        {
-            List<Emisor> respuesta = null;
-            try
-            {
-                respuesta = new EmisorDAL().ObtenerEmisor();
-
-            }
-            catch (Exception ex)
-            {
-                throw;
-            }
-            return respuesta;
-        }
-
-        [HttpPost]
-        public BaseJson InsertarActualizarEmisor(Emisor model)
-        {
-            BaseJson respuesta = new BaseJson();
-            try
-            {
-                respuesta = new EmisorDAL().InsertarActualizarEmisor(model);
-            }
-            catch (Exception ex)
-            {
-
-                throw;
-            }
-            return respuesta;
-        }
-
-
-        #endregion
-
-
-    }
-}
\ No newline at end of file
diff --git a/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/MantenimientoAPIController.cs b/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/MantenimientoAPIController.cs
deleted file mode 100644
index 724645a96..000000000
--- a/AYA.SlnSynor/AYA.SlnSynor/ControllersWebApi/Matenimimento/MantenimientoAPIController.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using AYA.SlnSinortModel.DAL.Sinort;
-using AYA.SlnSinortModel.Entidades;
-using AYA.SlnSinortModel.Sinort;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Web;
-using System.Web.Http;
-
-
-namespace AYA.SlnSinort.ControllersWebApi.Matenimimento
-{
-    public class MantenimientoAPIController : ApiController
-    {
-        
-        [HttpGet]
-        public List<Mantenimiento> ObtenerMantenimientoCatalogos()
-        {
-            List<Mantenimiento> respuesta = null;
-            try
-            {
-                respuesta = new MantenimientoDAL().ObtenerMantenimientoCatalogos();
-
-            }
-            catch (Exception ex)
-            {
-                throw;
-            }
-            return respuesta;
-        }
-
-
-       
-    }
-}
\ No newline at end of file
diff --git a/AYA.SlnSynor/AYA.SlnSynor/Views/Shared/_Layout.cshtml b/AYA.SlnSynor/AYA.SlnSynor/Views/Shared/_Layout.cshtml
index c69e1c7b8..950d37e8a 100644
--- a/AYA.SlnSynor/AYA.SlnSynor/Views/Shared/_Layout.cshtml
+++ b/AYA.SlnSynor/AYA.SlnSynor/Views/Shared/_Layout.cshtml
@@ -3,7 +3,7 @@
 <head>
 
     <meta charset="utf-8">
-  
+
     <meta name="viewport" content="width=device-width" />
     <title> AYA | SINORT </title>
     <!-- Tell the browser to be responsive to screen width -->
@@ -24,13 +24,13 @@
     <!-- Google Font -->
     <link rel="stylesheet"
           href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,600,700,300italic,400italic,600italic">
-    <link rel="stylesheet" href="~/Content/Principal.css" >
+    <link rel="stylesheet" href="~/Content/Principal.css">
     @*@Styles.Render("~/Content/dashboard")*@
-     @Scripts.Render("~/bundles/modernizr")
+    @Scripts.Render("~/bundles/modernizr")
     @Scripts.Render("~/bundles/jquery")
     @Scripts.Render("~/bundles/jquery-dataTables");
     @Styles.Render("~/Content/sinort-css")
-  
+
     @* Seccion futuros scripts *@
 </head>
 
@@ -49,30 +49,8 @@
                 <span class="logo-lg"><img src="~/dist/img/LogoAyA.jpg" alt="logo"></span>
             </a>
 
-         
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
             <nav class="navbar navbar-static-top" role="navigation">
 
-
-
-
-
                 <a href="#" class="sidebar-toggle" data-toggle="push-menu" role="button">
                     <span class="sr-only">Toggle navigation</span>
                 </a>
@@ -176,7 +154,7 @@
                                 <li class="user-body">
                                     <div class="row">
                                         <div class="col-xs-4 text-center">
-                                            <a href="#">usuaro@aya.go.cr</a>
+                                            <a href="#">usuario@aya.go.cr</a>
                                         </div>
                                         <div class="col-xs-4 text-center">
                                             <a href="#"></a>
@@ -212,77 +190,105 @@
 
                 @*<div class="user-panel">
                     <div class="pull-left image">
-                        <img src="~/dist/img/user2-160x160.jpg" class="img-circle" alt="User Image">
+                    <img src="~/dist/img/user2-160x160.jpg" class="img-circle" alt="User Image">
                     </div>
                     <div class="pull-left info">
-                        <p>Usuario</p>  Status 
-                        <a href="#"><i class="fa fa-circle text-success"></i> Bienvenido </a>
+                    <p>Usuario</p>  Status
+                    <a href="#"><i class="fa fa-circle text-success"></i> Bienvenido </a>
+                    </div>
                     </div>
-                </div>
 
-                <form action="#" method="get" class="sidebar-form">
+                    <form action="#" method="get" class="sidebar-form">
                     <div class="input-group">
-                        <input type="text" name="q" class="form-control" placeholder="Search...">
-                        <span class="input-group-btn">
-                            <button type="submit" name="search" id="search-btn" class="btn btn-flat">
-                                <i class="fa fa-search"></i>
-                            </button>
-                        </span>
+                    <input type="text" name="q" class="form-control" placeholder="Search...">
+                    <span class="input-group-btn">
+                    <button type="submit" name="search" id="search-btn" class="btn btn-flat">
+                    <i class="fa fa-search"></i>
+                    </button>
+                    </span>
                     </div>
-                </form>*@
+                    </form>*@
 
                 <ul class="sidebar-menu" data-widget="tree">
                     <li class="header">PANEL PRINCIPAL</li>
 
-                    <li class="treeview">
+                    @foreach (var option in ViewBag.ListaPantallas)
+                    {
+
+                        <li class="treeview">
+                            @if (@option.IdPadre == null)
+                            {
+                                <a href="#">
+                                    <i class="fa fa-book"></i>
+                                    <span>
+                                        @option.Descripcion
+                                    </span>
+                                    <span class="pull-right-container">
+                                        <i class="fa fa-angle-left pull-right"></i>
+                                    </span>
+                                </a>
+                            }
+
+                            @if (!string.IsNullOrWhiteSpace(option.Vista))
+                            {
+                                string[] mvc = @option.Vista.Split('/');
+                                <ul class="treeview-menu">
+                                    <li><a href="@Url.Action(mvc[1],mvc[0])"> @option.Descripcion</a></li>
+                                </ul>
+                            }
+
+                        </li>
+                    }
+
+                    @*<li class="treeview">
                         <a href="#">
-                            <i class="fa fa-book"></i> <span>Normativa y </br> Reglamentación Técnica </span> <span class="pull-right-container">
-                                <i class="fa fa-angle-left pull-right"></i>
-                            </span>
+                        <i class="fa fa-book"></i> <span>Normativa y </br> Reglamentación Técnica </span> <span class="pull-right-container">
+                        <i class="fa fa-angle-left pull-right"></i>
+                        </span>
                         </a>
                         <ul class="treeview-menu">
-                            <span><i class="fa fa-circle text-success"> Acciones</i>  </span>
-                            <li><a href="#">Pre-registro</a></li>
-                            <li><a href="#">Consulta de fichas </br> técnicas vigentes</a></li>
-                            <li><a href="#">Consulta de fichas </br> técnicas eliminadas</a></li>
-                            <li><a href="#">Consulta al </br> administrador</a></li>
-                            <li><a href="#">Compra de </br> documento técnico</a></li>
-                            <li><a href="#">Modificación de </br> documento técnico</a></li>
-                            <li><a href="#">Solicitudes de </br> compras abiertas</a></li>
-                            <li><a href="@Url.Action("Mantenimiento", "Catalogos")"> Configuración de la </br> aplicación</a></li>
-                            <li><a href="#">Encuestas</a></li>
+                        <span><i class="fa fa-circle text-success"> Acciones</i>  </span>
+                        <li><a href="#">Pre-registro</a></li>
+                        <li><a href="#">Consulta de fichas </br> técnicas vigentes</a></li>
+                        <li><a href="#">Consulta de fichas </br> técnicas eliminadas</a></li>
+                        <li><a href="#">Consulta al </br> administrador</a></li>
+                        <li><a href="#">Compra de </br> documento técnico</a></li>
+                        <li><a href="#">Modificación de </br> documento técnico</a></li>
+                        <li><a href="#">Solicitudes de </br> compras abiertas</a></li>
+                        <li><a href="@Url.Action("Mantenimiento", "Catalogos")"> Configuración de la </br> aplicación</a></li>
+                        <li><a href="#">Encuestas</a></li>
 
                         </ul>
-                    </li>
+                        </li>
 
-                    <li class="treeview">
+                        <li class="treeview">
                         <a href="#">
-                            <i class="fa fa-book"></i> <span> Proyectos Normativos </span> <span class="pull-right-container">
-                                <i class="fa fa-angle-left pull-right"></i>
-                            </span>
+                        <i class="fa fa-book"></i> <span> Proyectos Normativos </span> <span class="pull-right-container">
+                        <i class="fa fa-angle-left pull-right"></i>
+                        </span>
                         </a>
                         <ul class="treeview-menu">
-                            <span><i class="fa fa-circle text-success"> Acciones</i>  </span>
-                            <li><a href="#">Propuesta Normativa</a></li>
-                            <li><a href="#">Foro</a></li>
-                            <li><a href="#">Repositorios históricos</a></li>
-                            <li><a href="#">Proyectos Normativos Eliminados</a></li>
-                            <li><a href="#">Foros Eliminados</a></li>
+                        <span><i class="fa fa-circle text-success"> Acciones</i>  </span>
+                        <li><a href="#">Propuesta Normativa</a></li>
+                        <li><a href="#">Foro</a></li>
+                        <li><a href="#">Repositorios históricos</a></li>
+                        <li><a href="#">Proyectos Normativos Eliminados</a></li>
+                        <li><a href="#">Foros Eliminados</a></li>
                         </ul>
-                    </li>
-                    <li class="treeview">
+                        </li>
+                        <li class="treeview">
                         <a href="#">
-                            <i class="fa fa-book"></i> <span>Estadísticas y Reportes </span> <span class="pull-right-container">
-                                <i class="fa fa-angle-left pull-right"></i>
-                            </span>
+                        <i class="fa fa-book"></i> <span>Estadísticas y Reportes </span> <span class="pull-right-container">
+                        <i class="fa fa-angle-left pull-right"></i>
+                        </span>
                         </a>
                         <ul class="treeview-menu">
-                            <span><i class="fa fa-circle text-success"> Acciones</i>  </span>
-                            <li><a href="#">Reportes</a></li>
-                            <li><a href="#">Estadisticas</a></li>
-                            <li><a href="#">Documentos</a></li>
+                        <span><i class="fa fa-circle text-success"> Acciones</i>  </span>
+                        <li><a href="#">Reportes</a></li>
+                        <li><a href="#">Estadisticas</a></li>
+                        <li><a href="#">Documentos</a></li>
                         </ul>
-                    </li>
+                        </li>*@
 
                 </ul>
 
@@ -292,12 +298,12 @@
         <div id="main" class="content-wrapper">
 
 
-       
-                        @RenderSection("featured", required: false)
-                        @RenderBody()
-                        
-           
-            
+
+            @RenderSection("featured", required: false)
+            @RenderBody()
+
+
+
 
 
 
@@ -430,7 +436,7 @@
         <div class="control-sidebar-bg"></div>
     </div>
 
-    <input type="hidden" id="hiddenSinortWCF" value="@ViewBag.SinortWCF"/>
+    <input type="hidden" id="hiddenSinortWCF" value="@ViewBag.SinortWCF" />
     <input type="hidden" id="hiddenSinortCatalogosWCF" value="@ViewBag.SinortCatalogosWCF" />
 
 </body>
diff --git a/AYA.SlnSynor/AYA.SlnSynorModel.DAL/AYA.SlnSinortModel.DAL.csproj b/AYA.SlnSynor/AYA.SlnSynorModel.DAL/AYA.SlnSinortModel.DAL.csproj
index 3b5e86113..a984af5ea 100644
--- a/AYA.SlnSynor/AYA.SlnSynorModel.DAL/AYA.SlnSinortModel.DAL.csproj
+++ b/AYA.SlnSynor/AYA.SlnSynorModel.DAL/AYA.SlnSinortModel.DAL.csproj
@@ -66,6 +66,7 @@
     <Compile Include="Sinort\ForoDAL.cs" />
     <Compile Include="Sinort\MantenimientoDAL.cs" />
     <Compile Include="Sinort\MatrizDAL.cs" />
+    <Compile Include="Sinort\PantallasDAL.cs" />
     <Compile Include="Sinort\PermisosUsuarioDAL.cs" />
     <Compile Include="Sinort\PlantillaEmailDAL.cs" />
     <Compile Include="Sinort\RolesDAL.cs" />
diff --git a/AYA.SlnSynor/AYA.SlnSynorModel.DAL/Sinort/PantallasDAL.cs b/AYA.SlnSynor/AYA.SlnSynorModel.DAL/Sinort/PantallasDAL.cs
new file mode 100644
index 000000000..be1d2b8be
--- /dev/null
+++ b/AYA.SlnSynor/AYA.SlnSynorModel.DAL/Sinort/PantallasDAL.cs
@@ -0,0 +1,31 @@
+using AYA.SlnSinortModel.Sinort;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AYA.SlnSinortModel.DAL.Sinort
+{
+    public class PantallasDAL
+    {
+        public List<Pantallas> ObtenerPantallas(Usuario model)
+        {
+            List<Pantallas> registros = null;
+            try
+            {
+                using (SinortContex db = new SinortContex())
+                {
+                    registros = db.Pantallas.Where(t => t.Estado == true).OrderBy(q => q.IdPantalla).ToList();
+
+                }
+            }
+            catch (Exception ex)
+            {
+                //log.Error(ex);
+            }
+
+            return registros;
+        }
+    }
+}
diff --git a/AYA.SlnSynor/AYA.SlnSynorModel/AYA.SlnSinortModel.csproj b/AYA.SlnSynor/AYA.SlnSynorModel/AYA.SlnSinortModel.csproj
index 1ec21c440..67201eae9 100644
--- a/AYA.SlnSynor/AYA.SlnSynorModel/AYA.SlnSinortModel.csproj
+++ b/AYA.SlnSynor/AYA.SlnSynorModel/AYA.SlnSinortModel.csproj
@@ -72,6 +72,7 @@
     <Compile Include="Sinort\Foro.cs" />
     <Compile Include="Sinort\Mantenimiento.cs" />
     <Compile Include="Sinort\Matriz.cs" />
+    <Compile Include="Sinort\Pantallas.cs" />
     <Compile Include="Sinort\Partial\Contex.cs" />
     <Compile Include="Sinort\PermisosUsuario.cs" />
     <Compile Include="Sinort\PlantillaEmail.cs" />
diff --git a/AYA.SlnSynor/AYA.SlnSynorModel/Sinort/Pantallas.cs b/AYA.SlnSynor/AYA.SlnSynorModel/Sinort/Pantallas.cs
new file mode 100644
index 000000000..2bab47f14
--- /dev/null
+++ b/AYA.SlnSynor/AYA.SlnSynorModel/Sinort/Pantallas.cs
@@ -0,0 +1,36 @@
+namespace AYA.SlnSinortModel.Sinort
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel.DataAnnotations;
+    using System.ComponentModel.DataAnnotations.Schema;
+    using System.Data.Entity.Spatial;
+
+    [Table("Catalogos.Pantallas")]
+    public partial class Pantallas
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.None)]
+        public int IdPantalla { get; set; }
+
+        public int? IdPadre { get; set; }
+
+        [StringLength(100)]
+        public string Descripcion { get; set; }
+
+        [StringLength(200)]
+        public string Vista { get; set; }
+
+        public bool? Estado { get; set; }
+
+        public DateTime? FechaCreacion { get; set; }
+
+        [StringLength(200)]
+        public string UsuarioCreacion { get; set; }
+
+        public DateTime? FechaModificacion { get; set; }
+
+        [StringLength(200)]
+        public string UsuarioModificacion { get; set; }
+    }
+}
diff --git a/AYA.SlnSynor/AYA.SlnSynorModel/Sinort/SinortContex.cs b/AYA.SlnSynor/AYA.SlnSynorModel/Sinort/SinortContex.cs
new file mode 100644
index 000000000..c079c6b92
--- /dev/null
+++ b/AYA.SlnSynor/AYA.SlnSynorModel/Sinort/SinortContex.cs
@@ -0,0 +1,375 @@
+using System;
+using System.Data.Entity;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using AYA.SlnSinortModel.Sinort.Partial;
+
+namespace AYA.SlnSinortModel.Sinort
+{
+
+    public partial class SinortContex : Contex
+    {
+        public virtual DbSet<Aplicacion> Aplicacion { get; set; }
+        public virtual DbSet<Categoria> Categoria { get; set; }
+        public virtual DbSet<Emisor> Emisor { get; set; }
+        public virtual DbSet<Estado> Estado { get; set; }
+        public virtual DbSet<Mantenimiento> Mantenimiento { get; set; }
+        public virtual DbSet<Pantallas> Pantallas { get; set; }
+        public virtual DbSet<PermisosUsuario> PermisosUsuario { get; set; }
+        public virtual DbSet<PlantillaEmail> PlantillaEmail { get; set; }
+        public virtual DbSet<Roles> Roles { get; set; }
+        public virtual DbSet<TipoAplicacion> TipoAplicacion { get; set; }
+        public virtual DbSet<TipoDocumento> TipoDocumento { get; set; }
+        public virtual DbSet<TipoEmisor> TipoEmisor { get; set; }
+        public virtual DbSet<TipoEstado> TipoEstado { get; set; }
+        public virtual DbSet<TipoForo> TipoForo { get; set; }
+        public virtual DbSet<TipoMatriz> TipoMatriz { get; set; }
+        public virtual DbSet<Usuario> Usuario { get; set; }
+        public virtual DbSet<BitacoraDocumentos> BitacoraDocumentos { get; set; }
+        public virtual DbSet<Documentos> Documentos { get; set; }
+        public virtual DbSet<DocumentosAdjuntos> DocumentosAdjuntos { get; set; }
+        public virtual DbSet<ComentariosForo> ComentariosForo { get; set; }
+        public virtual DbSet<ComentariosMatriz> ComentariosMatriz { get; set; }
+        public virtual DbSet<Convocatoria> Convocatoria { get; set; }
+        public virtual DbSet<Foro> Foro { get; set; }
+        public virtual DbSet<Matriz> Matriz { get; set; }
+
+        protected override void OnModelCreating(DbModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Aplicacion>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Aplicacion>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Aplicacion>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Categoria>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Categoria>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Categoria>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Emisor>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Emisor>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Emisor>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Estado>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Estado>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Estado>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Mantenimiento>()
+                .Property(e => e.Catalogo)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Mantenimiento>()
+                .Property(e => e.Vista)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Mantenimiento>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Mantenimiento>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Pantallas>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Pantallas>()
+                .Property(e => e.Vista)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Pantallas>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Pantallas>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<PermisosUsuario>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<PermisosUsuario>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<PlantillaEmail>()
+                .Property(e => e.NombrePlatilla)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<PlantillaEmail>()
+                .Property(e => e.Body)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<PlantillaEmail>()
+                .Property(e => e.Subject)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<PlantillaEmail>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<PlantillaEmail>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Roles>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Roles>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Roles>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoAplicacion>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoAplicacion>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoAplicacion>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoDocumento>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoDocumento>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoDocumento>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoEmisor>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoEmisor>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoEmisor>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoEstado>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoEstado>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoEstado>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoForo>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoForo>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoForo>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoMatriz>()
+                .Property(e => e.Descripcion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoMatriz>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<TipoMatriz>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Usuario>()
+                .Property(e => e.UsuarioSistema)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Usuario>()
+                .Property(e => e.NombreUsuario)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Usuario>()
+                .Property(e => e.EmailUsuario)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Usuario>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Usuario>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Usuario>()
+                .HasMany(e => e.Convocatoria)
+                .WithRequired(e => e.Usuario)
+                .WillCascadeOnDelete(false);
+
+            modelBuilder.Entity<BitacoraDocumentos>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<BitacoraDocumentos>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Documentos>()
+                .Property(e => e.NombreDocumento)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Documentos>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Documentos>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Documentos>()
+                .HasMany(e => e.BitacoraDocumentos)
+                .WithRequired(e => e.Documentos)
+                .WillCascadeOnDelete(false);
+
+            modelBuilder.Entity<DocumentosAdjuntos>()
+                .Property(e => e.Nombre)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<DocumentosAdjuntos>()
+                .Property(e => e.TipoArchivo)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<DocumentosAdjuntos>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<DocumentosAdjuntos>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosForo>()
+                .Property(e => e.Asunto)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosForo>()
+                .Property(e => e.Respuesta)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosForo>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosForo>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.Asunto)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.Capitulo)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.ApartadoSeccionParrafo)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.TextoOriginal)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.TextoPropuesto)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.ComentarioObservacionJustificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<ComentariosMatriz>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Convocatoria>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Convocatoria>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Foro>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Foro>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Foro>()
+                .HasMany(e => e.Convocatoria)
+                .WithRequired(e => e.Foro)
+                .WillCascadeOnDelete(false);
+
+            modelBuilder.Entity<Matriz>()
+                .Property(e => e.UsuarioCreacion)
+                .IsUnicode(false);
+
+            modelBuilder.Entity<Matriz>()
+                .Property(e => e.UsuarioModificacion)
+                .IsUnicode(false);
+        }
+    }
+}
diff --git a/AYA.SlnSynor/Atesa.Utilitarios/Atesa.Utilitarios.csproj b/AYA.SlnSynor/Atesa.Utilitarios/Atesa.Utilitarios.csproj
index 672bf68d4..0bd4919a4 100644
--- a/AYA.SlnSynor/Atesa.Utilitarios/Atesa.Utilitarios.csproj
+++ b/AYA.SlnSynor/Atesa.Utilitarios/Atesa.Utilitarios.csproj
@@ -37,6 +37,10 @@
     <Reference Include="APCEncryptLibrary">
       <HintPath>..\..\..\..\..\..\..\..\DLL\APCEncryptLibrary.dll</HintPath>
     </Reference>
+    <Reference Include="log4net, Version=2.0.8.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
+      <HintPath>..\packages\log4net.2.0.8\lib\net45-full\log4net.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="Newtonsoft.Json, Version=11.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <HintPath>..\packages\Newtonsoft.Json.11.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
       <Private>True</Private>
diff --git a/AYA.SlnSynor/Atesa.Utilitarios/packages.config b/AYA.SlnSynor/Atesa.Utilitarios/packages.config
index ea50f8628..80c11fc6c 100644
--- a/AYA.SlnSynor/Atesa.Utilitarios/packages.config
+++ b/AYA.SlnSynor/Atesa.Utilitarios/packages.config
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="log4net" version="2.0.8" targetFramework="net45" />
   <package id="Newtonsoft.Json" version="11.0.2" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net20-full/log4net.dll b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net20-full/log4net.dll
new file mode 100644
index 0000000000000000000000000000000000000000..27a2be013788c629a4c81068ee102773408f6640
GIT binary patch
literal 278528
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

literal 0
HcmV?d00001

diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net20-full/log4net.xml b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net20-full/log4net.xml
new file mode 100644
index 000000000..8b3fcaf56
--- /dev/null
+++ b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net20-full/log4net.xml
@@ -0,0 +1,31421 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>log4net</name>
+    </assembly>
+    <members>
+        <member name="T:log4net.Appender.AdoNetAppender">
+            <summary>
+            Appender that logs to a database.
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
+            database. The appender can be configured to specify the connection 
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
+            property. For more information on database connection strings for
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
+            </para>
+            <para>
+            Records are written into the database either using a prepared
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
+            procedure.
+            </para>
+            <para>
+            The prepared statement text or the name of the stored procedure
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
+            </para>
+            <para>
+            The prepared statement or stored procedure can take a number
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
+            type may be subclassed if required to provide database specific
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
+            the parameter name, database type, size, and how the value should
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
+            </para>
+            </remarks>
+            <example>
+            An example of a SQL Server table that could be logged to:
+            <code lang="SQL">
+            CREATE TABLE [dbo].[Log] ( 
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,
+              [Date] [datetime] NOT NULL ,
+              [Thread] [varchar] (255) NOT NULL ,
+              [Level] [varchar] (20) NOT NULL ,
+              [Logger] [varchar] (255) NOT NULL ,
+              [Message] [varchar] (4000) NOT NULL 
+            ) ON [PRIMARY]
+            </code>
+            </example>
+            <example>
+            An example configuration to log to the above table:
+            <code lang="XML" escaped="true">
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
+              <parameter>
+                <parameterName value="@log_date"/>
+                <dbType value="DateTime"/>
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@thread"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@log_level"/>
+                <dbType value="String"/>
+                <size value="50"/>
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@logger"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@message"/>
+                <dbType value="String"/>
+                <size value="4000"/>
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>
+              </parameter>
+            </appender>
+            </code>
+            </example>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Lance Nehring</author>
+        </member>
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
+            buffers events in a fixed size buffer.
+            </summary>
+            <remarks>
+            <para>
+            This base class should be used by appenders that need to buffer a 
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            buffers events and then submits the entire contents of the buffer to 
+            the underlying database in one go.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:SendBuffer(LoggingEvent[])"/>
+            method to deliver the buffered events.
+            </para>
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
+            buffer of events. The size of the buffer is set using 
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
+            </para>
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
+            triggers, then the current buffer is sent immediately 
+            (see <see cref="M:SendBuffer(LoggingEvent[])"/>). Otherwise the event 
+            is stored in the buffer. For example, an evaluator can be used to 
+            deliver the events immediately when an ERROR event arrives.
+            </para>
+            <para>
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
+            By default the appender is NOT lossy. When the buffer is full all 
+            the buffered events are sent with <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
+            buffer will not be sent when it is full, and new events arriving 
+            in the appender will overwrite the oldest event in the buffer. 
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
+            triggers. This can be useful behavior when you need to know about 
+            ERROR events but not about events with a lower level, configure an 
+            evaluator that will trigger when an ERROR event arrives, the whole 
+            buffer will be sent which gives a history of events leading up to
+            the ERROR event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.AppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
+            </summary>
+            <remarks>
+            <para>
+            This class provides the code for common functionality, such 
+            as support for threshold filtering and support for general filters.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.IAppender">
+            <summary>
+            Implement this interface for your own strategies for printing log statements.
+            </summary>
+            <remarks>
+            <para>
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
+            class which provides a default implementation of this interface.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.IAppender.Close">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logging event in Appender specific way.
+            </summary>
+            <param name="loggingEvent">The event to log</param>
+            <remarks>
+            <para>
+            This method is called to log a message into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.IAppender.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>The name uniquely identifies the appender.</para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IBulkAppender">
+            <summary>
+            Interface for appenders that support bulk logging.
+            </summary>
+            <remarks>
+            <para>
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
+            should only implement this interface if they can bulk log efficiently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Log the array of logging events in Appender specific way.
+            </summary>
+            <param name="loggingEvents">The events to log</param>
+            <remarks>
+            <para>
+            This method is called to log an array of events into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IOptionHandler">
+            <summary>
+            Interface used to delay activate a configured object.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
+            must be called by the container after its all the configured properties have been set 
+            and before the component can be used.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
+            <summary>
+            Activate the options that were previously set with calls to properties.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then this method must be called
+            after its properties have been set before the component can be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IFlushable">
+            <summary>
+            Interface that can be implemented by Appenders that buffer logging data and expose a <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.IFlushable.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            Appenders that implement the <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method must do so in a thread-safe manner: it can be called concurrently with
+            the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            <para>
+            Typically this is done by locking on the Appender instance, e.g.:
+            <code>
+            <![CDATA[
+            public bool Flush(int millisecondsTimeout)
+            {
+                lock(this)
+                {
+                    // Flush buffered logging data
+                    ...
+                }
+            }
+            ]]>
+            </code>
+            </para>
+            <para>
+            The <paramref name="millisecondsTimeout"/> parameter is only relevant for appenders that process logging events asynchronously,
+            such as <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            </remarks>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>Empty default constructor</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
+            <summary>
+            Finalizes this appender by calling the implementation's 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
+            </summary>
+            <remarks>
+            <para>
+            If this appender has not been closed then the <c>Finalize</c> method
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">
+            <summary>
+            Closes the appender and release resources.
+            </summary>
+            <remarks>
+            <para>
+            Release any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            <para>
+            This method cannot be overridden by subclasses. This method 
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
+            method which must be overridden in the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent)"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>
+            will be passed to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent[])"/> method.
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent[])"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvents"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvents"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>
+            will be passed to the <see cref="M:Append(LoggingEvent[])"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if the logging event should we output by this appender
+            </summary>
+            <param name="loggingEvent">the event to test</param>
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
+            <remarks>
+            <para>
+            This method checks the logging event against the threshold level set
+            on this appender and also against the filters specified on this
+            appender.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
+            <summary>
+            Adds a filter to the end of the filter chain.
+            </summary>
+            <param name="filter">the filter to add to this appender</param>
+            <remarks>
+            <para>
+            The Filters are organized in a linked list.
+            </para>
+            <para>
+            Setting this property causes the new filter to be pushed onto the 
+            back of the filter chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
+            <summary>
+            Clears the filter list for this appender.
+            </summary>
+            <remarks>
+            <para>
+            Clears the filter list for this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
+            <summary>
+            Checks if the message level is below this appender's threshold.
+            </summary>
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
+            <remarks>
+            <para>
+            If there is no threshold set, then the return value is always <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
+            requirements of this appender.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
+            <summary>
+            Is called when the appender is closed. Derived classes should override 
+            this method if resources need to be released.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
+            to perform actual logging.
+            </summary>
+            <param name="loggingEvent">The event to append.</param>
+            <remarks>
+            <para>
+            A subclass must implement this method to perform
+            logging of the <paramref name="loggingEvent"/>.
+            </para>
+            <para>This method will be called by <see cref="M:DoAppend(LoggingEvent)"/>
+            if all the conditions listed for that method are met.
+            </para>
+            <para>
+            To restrict the logging of events in the appender
+            override the <see cref="M:PreAppendCheck()"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append a bulk array of logging events.
+            </summary>
+            <param name="loggingEvents">the array of logging events</param>
+            <remarks>
+            <para>
+            This base class implementation calls the <see cref="M:Append(LoggingEvent)"/>
+            method for each element in the bulk array.
+            </para>
+            <para>
+            A sub class that can better process a bulk array of events should
+            override this method in addition to <see cref="M:Append(LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
+            <summary>
+            Called before <see cref="M:Append(LoggingEvent)"/> as a precondition.
+            </summary>
+            <remarks>
+            <para>
+            This method is called by <see cref="M:DoAppend(LoggingEvent)"/>
+            before the call to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            This method can be overridden in a subclass to extend the checks 
+            made before the event is passed to the <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            A subclass should ensure that they delegate this call to
+            this base class if it is overridden.
+            </para>
+            </remarks>
+            <returns><c>true</c> if the call to <see cref="M:Append(LoggingEvent)"/> should proceed.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <returns>The event rendered as a string.</returns>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Where possible use the alternative version of this method
+            <see cref="M:RenderLoggingEvent(TextWriter,LoggingEvent)"/>.
+            That method streams the rendering onto an existing Writer
+            which can give better performance if the caller already has
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>
+            where possible. If, however, the caller needs to render the event
+            to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does
+            provide an efficient mechanism for doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            This implementation doesn't flush anything and always returns true
+            </remarks>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
+            <summary>
+            The layout of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
+            <summary>
+            The name of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
+            <summary>
+            The level threshold of this appender.
+            </summary>
+            <remarks>
+            <para>
+            There is no level threshold filtering by default.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
+            <summary>
+            It is assumed and enforced that errorHandler is never null.
+            </summary>
+            <remarks>
+            <para>
+            It is assumed and enforced that errorHandler is never null.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
+            <summary>
+            The first filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>null</c> initially.
+            </para>
+            <para>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
+            <summary>
+            The last filter in the filter chain.
+            </summary>
+            <remarks>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
+            <summary>
+            Flag indicating if this appender is closed.
+            </summary>
+            <remarks>
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
+            <summary>
+            The guard prevents an appender from repeatedly calling its own DoAppend method
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
+            <summary>
+            StringWriter used to render events
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.declaringType">
+            <summary>
+            The fully qualified type of the AppenderSkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
+            <summary>
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
+            </summary>
+            <value>
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
+            </value>
+            <remarks>
+            <para>
+            All log events with lower level than the threshold level are ignored 
+            by the appender.
+            </para>
+            <para>
+            In configuration files this option is specified by setting the
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
+            string, such as "DEBUG", "INFO" and so on.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </summary>
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
+            <summary>
+            The filter chain.
+            </summary>
+            <value>The head of the filter chain filter chain.</value>
+            <remarks>
+            <para>
+            Returns the head Filter. The Filters are organized in a linked list
+            and so all Filters on this Appender are available through the result.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
+            </summary>
+            <value>The layout of the appender.</value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>
+            The name uniquely identifies the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
+            <summary>
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <remarks>
+            <para>
+            In the rather exceptional case, where the appender 
+            implementation admits a layout but can also work without it, 
+            then the appender should return <c>true</c>.
+            </para>
+            <para>
+            This default implementation always returns <c>false</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
+            <summary>
+            The default buffer size.
+            </summary>
+            <remarks>
+            The default size of the cyclic buffer used to store events.
+            This is set to 512 by default.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <param name="eventMustBeFixed">the events passed through this appender must be
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
+            <remarks>
+            <para>
+            Protected constructor to allow subclassing.
+            </para>
+            <para>
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass
+            expects the events delivered to be fixed even if the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <remarks>
+            <para>
+            Flushes any events that have been buffered.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will NOT be flushed to the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
+            <remarks>
+            <para>
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
+            In this case the contents of the buffer will be tested against the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
+            events will be discarded.
+            </para>
+            <para>
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
+            be emptied by calling this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
+            <summary>
+            Close this appender instance.
+            </summary>
+            <remarks>
+            <para>
+            Close this appender instance. If this appender is marked
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
+            the buffer must be sent when the appender is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
+            </para>
+            <para>
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
+            method) if one of the following conditions is met:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>The cyclic buffer is full and this appender is
+            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
+            	</item>
+            	<item>
+            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
+            		it is triggered for the <paramref name="loggingEvent"/>
+            		specified.</description>
+            	</item>
+            </list>
+            <para>
+            Before the event is stored in the buffer it is fixed
+            (see <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/>) to ensure that
+            any data referenced by the event will be valid when the buffer
+            is processed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
+            <summary>
+            Sends the contents of the buffer.
+            </summary>
+            <param name="firstLoggingEvent">The first logging event.</param>
+            <param name="buffer">The buffer containing the events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override this method to process the buffered events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
+            <summary>
+            The size of the cyclic buffer used to hold the logging events.
+            </summary>
+            <remarks>
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
+            <summary>
+            The cyclic buffer used to store the logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
+            <summary>
+            The triggering event evaluator that causes the buffer to be sent immediately.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event causes the entire
+            buffer to be sent immediately. This field can be <c>null</c>, which 
+            indicates that event triggering is not to be done. The evaluator
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
+            <summary>
+            Indicates if the appender should overwrite events in the cyclic buffer 
+            when it becomes full, or if the buffer should be flushed when the 
+            buffer is full.
+            </summary>
+            <remarks>
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
+            be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
+            <summary>
+            The triggering event evaluator filters discarded events.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event that is discarded should
+            really be discarded or if it should be sent to the appenders. 
+            This field can be <c>null</c>, which indicates that all discarded events will
+            be discarded. 
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
+            <summary>
+            The events delivered to the subclass must be fixed.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
+            <summary>
+            Gets or sets a value that indicates whether the appender is lossy.
+            </summary>
+            <value>
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            This appender uses a buffer to store logging events before 
+            delivering them. A triggering event causes the whole buffer
+            to be send to the remote sink. If the buffer overruns before
+            a triggering event then logging events could be lost. Set
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
+            from being lost.
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
+            <summary>
+            Gets or sets the size of the cyclic buffer used to hold the 
+            logging events.
+            </summary>
+            <value>
+            The size of the cyclic buffer used to hold the logging events.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
+            representing the maximum number of logging events to collect in 
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
+            oldest events are deleted as new events are added to the
+            buffer. By default the size of the cyclic buffer is 512 events.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
+            or equal to 1 then no buffering will occur. The logging event
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
+            be buffered.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
+            buffer to be sent immediately.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
+            sent immediately.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is appended to this 
+            appender. If the evaluator triggers then the current buffer will 
+            immediately be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
+            <summary>
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </summary>
+            <value>
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is discarded from this 
+            appender. If the evaluator triggers then the current buffer will immediately 
+            be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating if only part of the logging event data
+            should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the
+            event data to be fixed and serialized. This will improve performance.
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
+            <summary>
+            Gets or sets a the fields that will be fixed in the event
+            </summary>
+            <value>
+            The event fields that will be fixed before the event is buffered
+            </value>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
+            <summary> 
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
+            </summary>
+            <remarks>
+            Public default constructor to initialize a new instance of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
+            <summary>
+            Override the parent method to close the database
+            </summary>
+            <remarks>
+            <para>
+            Closes the database command and database connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Inserts the events into the database.
+            </summary>
+            <param name="events">The events to insert into the database.</param>
+            <remarks>
+            <para>
+            Insert all the events specified in the <paramref name="events"/>
+            array into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
+            <summary>
+            Adds a parameter to the command.
+            </summary>
+            <param name="parameter">The parameter to add to the command.</param>
+            <remarks>
+            <para>
+            Adds a parameter to the ordered list of command parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
+            <summary>
+            Writes the events to the database using the transaction specified.
+            </summary>
+            <param name="dbTran">The transaction that the events will be executed under.</param>
+            <param name="events">The array of events to insert into the database.</param>
+            <remarks>
+            <para>
+            The transaction argument can be <c>null</c> if the appender has been
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
+            property for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
+            <summary>
+            Formats the log message into database statement text.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            This method can be overridden by subclasses to provide 
+            more control over the format of the database statement.
+            </remarks>
+            <returns>
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.CreateConnection(System.Type,System.String)">
+            <summary>
+            Creates an <see cref="T:System.Data.IDbConnection"/> instance used to connect to the database.
+            </summary>
+            <remarks>
+            This method is called whenever a new IDbConnection is needed (i.e. when a reconnect is necessary).
+            </remarks>
+            <param name="connectionType">The <see cref="T:System.Type"/> of the <see cref="T:System.Data.IDbConnection"/> object.</param>
+            <param name="connectionString">The connectionString output from the ResolveConnectionString method.</param>
+            <returns>An <see cref="T:System.Data.IDbConnection"/> instance with a valid connection string.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionString(System.String@)">
+            <summary>
+            Resolves the connection string from the ConnectionString, ConnectionStringName, or AppSettingsKey
+            property.
+            </summary>
+            <remarks>
+            ConnectiongStringName is only supported on .NET 2.0 and higher.
+            </remarks>
+            <param name="connectionStringContext">Additional information describing the connection string.</param>
+            <returns>A connection string used to connect to the database.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
+            <summary>
+            Retrieves the class type of the ADO.NET provider.
+            </summary>
+            <remarks>
+            <para>
+            Gets the Type of the ADO.NET provider to use to connect to the
+            database. This method resolves the type specified in the 
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
+            </para>
+            <para>
+            Subclasses can override this method to return a different type
+            if necessary.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
+            <summary>
+            Connects to the database.
+            </summary>		
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.DiposeConnection">
+            <summary>
+            Cleanup the existing connection.
+            </summary>
+            <remarks>
+            Calls the IDbConnection's <see cref="M:System.Data.IDbConnection.Close"/> method.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
+            <summary>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </summary>
+            <remarks>
+            <para>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
+            <summary>
+            The <see cref="T:System.Data.IDbConnection"/> that will be used
+            to insert logging events into a database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
+            <summary>
+            Database connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_appSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
+            <summary>
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
+            <summary>
+            The text of the command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
+            <summary>
+            The command type.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
+            <summary>
+            Indicates whether to reconnect when a connection is lost.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.declaringType">
+            <summary>
+            The fully qualified type of the AdoNetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
+            <summary>
+            Gets or sets the database connection string that is used to connect to 
+            the database.
+            </summary>
+            <value>
+            The database connection string used to connect to the database.
+            </value>
+            <remarks>
+            <para>
+            The connections string is specific to the connection type.
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
+            </para>
+            </remarks>
+            <example>Connection string for MS Access via ODBC:
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
+            </example>
+            <example>Another connection string for MS Access via ODBC:
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
+            </example>
+            <example>Connection string for MS Access via OLE DB:
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.AppSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+            <remarks>
+            This property requires at least .NET 2.0.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
+            <summary>
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
+            that should be created.
+            </summary>
+            <value>
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
+            </value>
+            <remarks>
+            <para>
+            The type name of the ADO.NET provider to use.
+            </para>
+            <para>
+            The default is to use the OLE DB provider.
+            </para>
+            </remarks>
+            <example>Use the OLE DB Provider. This is the default value.
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the MS SQL Server Provider. 
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the ODBC Provider. 
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>ODBC .NET Data Provider</b>.
+            </example>
+            <example>Use the Oracle Provider. 
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>.NET Managed Provider for Oracle</b>.
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
+            <summary>
+            Gets or sets the command text that is used to insert logging events
+            into the database.
+            </summary>
+            <value>
+            The command text used to insert logging events into the database.
+            </value>
+            <remarks>
+            <para>
+            Either the text of the prepared statement or the
+            name of the stored procedure to execute to write into
+            the database.
+            </para>
+            <para>
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
+            this text is a prepared statement or a stored procedure.
+            </para>
+            <para>
+            If this property is not set, the command text is retrieved by invoking
+            <see cref="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
+            <summary>
+            Gets or sets the command type to execute.
+            </summary>
+            <value>
+            The command type to execute.
+            </value>
+            <remarks>
+            <para>
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
+            to execute.
+            </para>
+            <para>
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
+            <summary>
+            Should transactions be used to insert logging events in the database.
+            </summary>
+            <value>
+            <c>true</c> if transactions should be used to insert logging events in
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a value that indicates whether transactions should be used
+            to insert logging events in the database.
+            </para>
+            <para>
+            When set a single transaction will be used to insert the buffered events
+            into the database. Otherwise each event will be inserted without using
+            an explicit transaction.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
+            <summary>
+            Should this appender try to reconnect to the database on error.
+            </summary>
+            <value>
+            <c>true</c> if the appender should try to reconnect to the database after an
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
+            i.e. not to try to reconnect.
+            </value>
+            <remarks>
+            <para>
+            The default behaviour is for the appender not to try to reconnect to the
+            database if an error occurs. Subsequent logging events are discarded.
+            </para>
+            <para>
+            To force the appender to attempt to reconnect to the database set this
+            property to <c>true</c>.
+            </para>
+            <note>
+            When the appender attempts to connect to the database there may be a
+            delay of up to the connection timeout specified in the connection string.
+            This delay will block the calling application's thread. 
+            Until the connection can be reestablished this potential delay may occur multiple times.
+            </note>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Data.IDbConnection"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">
+            <summary>
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            This class provides the basic database parameter properties
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
+            </para>
+            <para>This type can be subclassed to provide database specific
+            functionality. The two methods that are called externally are
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.
+            </summary>
+            <remarks>
+            Default constructor for the AdoNetAppenderParameter class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">
+            <summary>
+            Prepare the specified database command object.
+            </summary>
+            <param name="command">The command to prepare.</param>
+            <remarks>
+            <para>
+            Prepares the database command object by adding
+            this parameter to its collection of parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the logging event and set the parameter value in the command.
+            </summary>
+            <param name="command">The command containing the parameter.</param>
+            <param name="loggingEvent">The event to be rendered.</param>
+            <remarks>
+            <para>
+            Renders the logging event using this parameters layout
+            object. Sets the value of the parameter on the command object.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">
+            <summary>
+            The name of this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">
+            <summary>
+            The database type for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">
+            <summary>
+            Flag to infer type rather than use the DbType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">
+            <summary>
+            The precision for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">
+            <summary>
+            The scale for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">
+            <summary>
+            The size for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">
+            <summary>
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the
+            logging event into an object for this parameter.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">
+            <summary>
+            Gets or sets the name of this parameter.
+            </summary>
+            <value>
+            The name of this parameter.
+            </value>
+            <remarks>
+            <para>
+            The name of this parameter. The parameter name
+            must match up to a named parameter to the SQL stored procedure
+            or prepared statement.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">
+            <summary>
+            Gets or sets the database type for this parameter.
+            </summary>
+            <value>
+            The database type for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The database type for this parameter. This property should
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the type from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">
+            <summary>
+            Gets or sets the precision for this parameter.
+            </summary>
+            <value>
+            The precision for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum number of digits used to represent the Value.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the precision from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">
+            <summary>
+            Gets or sets the scale for this parameter.
+            </summary>
+            <value>
+            The scale for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The number of decimal places to which Value is resolved.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the scale from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">
+            <summary>
+            Gets or sets the size for this parameter.
+            </summary>
+            <value>
+            The size for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum size, in bytes, of the data within the column.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the size from the value.
+            </para>
+            <para>
+            For BLOB data types like VARCHAR(max) it may be impossible to infer the value automatically, use -1 as the size in this case.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to 
+            render the logging event into an object for this 
+            parameter.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the
+            logging event into an object for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this
+            parameter.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>
+            for use in the property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">
+            <summary>
+            Appends logging events to the terminal using ANSI color escape sequences.
+            </summary>
+            <remarks>
+            <para>
+            AnsiColorTerminalAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific level of message to be set.
+            </para>
+            <note>
+            This appender expects the terminal to understand the VT100 control set 
+            in order to interpret the color codes. If the terminal or console does not
+            understand the control codes the behavior is not defined.
+            </note>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            <para>
+            When configuring the ANSI colored terminal appender, a mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red"/>
+                <attributes value="Bright,Underscore"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            </list>
+            These color values cannot be combined together to make new colors.
+            </para>
+            <para>
+            The attributes can be any combination of the following:
+            <list type="bullet">
+            <item><term>Bright</term><description>foreground is brighter</description></item>
+            <item><term>Dim</term><description>foreground is dimmer</description></item>
+            <item><term>Underscore</term><description>message is underlined</description></item>
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>
+            <item><term>Hidden</term><description>output is hidden</description></item>
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>
+            </list>
+            While any of these attributes may be combined together not all combinations
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes
+            no sense.
+            </para>
+            </remarks>
+            <author>Patrick Wagstrom</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">
+            <summary>
+            Ansi code to reset terminal
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colours
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">
+            <summary>
+            The enum of possible display attributes
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the ANSI color attributes.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">
+            <summary>
+            text is bright
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">
+            <summary>
+            text is dim
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">
+            <summary>
+            text is underlined
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">
+            <summary>
+            text is blinking
+            </summary>
+            <remarks>
+            Not all terminals support this attribute
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">
+            <summary>
+            text and background colors are reversed
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">
+            <summary>
+            text is hidden
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">
+            <summary>
+            text is displayed with a strikethrough
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Light">
+            <summary>
+            text color is light
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">
+            <summary>
+            The enum of possible foreground or background color values for 
+            use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The output can be in one for the following ANSI colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">
+            <summary>
+            color is black
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">
+            <summary>
+            color is magenta
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMappingEntry">
+            <summary>
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract base class for types that are stored in the
+            <see cref="T:log4net.Util.LevelMapping"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">
+            <summary>
+            Default protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Default protected constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
+            <summary>
+            Initialize any options defined on this entry
+            </summary>
+            <remarks>
+            <para>
+            Should be overridden by any classes that need to initialise based on their options
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LevelMappingEntry.Level">
+            <summary>
+            The level that is the key for this mapping 
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping 
+            </value>
+            <remarks>
+            <para>
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
+            mapping subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together
+            and append the attributes.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">
+            <summary>
+            The color attributes for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The color attributes for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            An <c>AppenderCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">
+            <summary>
+            An empty readonly static AppenderCollection
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <c>AppenderCollection</c>.
+            </summary>
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">
+            <summary>
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clear">
+            <summary>
+            Removes all elements from the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>
+            in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">
+            <summary>
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">
+            <summary>
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">
+            <summary>
+            Return the collection elements as an array
+            </summary>
+            <returns>the array</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            	<para><paramref name="index"/> is less than zero</para>
+            	<para>-or-</para>
+            	<para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Appender.AspNetTraceAppender">
+            <summary>
+            <para>
+            Appends log events to the ASP.NET <see cref="T:System.Web.TraceContext"/> system.
+            </para>
+            </summary>
+            <remarks>
+            <para>
+            Diagnostic information and tracing messages that you specify are appended to the output 
+            of the page that is sent to the requesting browser. Optionally, you can view this information
+            from a separate trace viewer (Trace.axd) that displays trace information for every page in a 
+            given application.
+            </para>
+            <para>
+            Trace statements are processed and displayed only when tracing is enabled. You can control 
+            whether tracing is displayed to a page, to the trace viewer, or both.
+            </para>
+            <para>
+            The logging event is passed to the <see cref="M:TraceContext.Write(string)"/> or 
+            <see cref="M:TraceContext.Warn(string)"/> method depending on the level of the logging event.
+            The event's logger name is the default value for the category parameter of the Write/Warn method. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AspNetTraceAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the ASP.NET trace
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the ASP.NET trace
+            <c>HttpContext.Current.Trace</c> 
+            (<see cref="T:System.Web.TraceContext"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AspNetTraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.BufferingForwardingAppender">
+            <summary>
+            Buffers events and then forwards them to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The events are buffered in this appender until conditions are
+            met to allow the appender to deliver the events to the attached 
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the
+            conditions that cause the buffer to be sent.
+            </para>
+            <para>The forwarding appender can be used to specify different 
+            thresholds and filters for the same appender at different locations 
+            within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Core.IAppenderAttachable">
+            <summary>
+            Interface for attaching appenders to objects.
+            </summary>
+            <remarks>
+            <para>
+            Interface for attaching, removing and retrieving appenders.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="appender">The appender to add.</param>
+            <remarks>
+            <para>
+            Add the specified appender. The implementation may
+            choose to allow or deny duplicate appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Returns an attached appender with the <paramref name="name"/> specified.
+            If no appender with the specified name is found <c>null</c> will be
+            returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <value>
+            A collection of attached appenders.
+            </value>
+            <remarks>
+            <para>
+            Gets a collection of attached appenders.
+            If there are no attached appenders the
+            implementation should return an empty 
+            collection rather than <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            Forwards the events to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this buffering appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes directly to the application's attached console
+            not to the <c>System.Console.Out</c> or <c>System.Console.Error</c> <c>TextWriter</c>.
+            The <c>System.Console.Out</c> and <c>System.Console.Error</c> streams can be
+            programmatically redirected (for example NUnit does this to capture program output).
+            This appender will ignore these redirections because it needs to use Win32
+            API calls to colorize the output. To respect these redirections the <see cref="T:log4net.Appender.ConsoleAppender"/>
+            must be used.
+            </para>
+            <para>
+            When configuring the colored console appender, mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red, HighIntensity"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            combination of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            <item><term>HighIntensity</term><description></description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.AddMapping(log4net.Appender.ColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_consoleOutputWriter">
+            <summary>
+            The console output stream writer to write to
+            </summary>
+            <remarks>
+            <para>
+            This writer is not thread safe.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.Colors">
+            <summary>
+            The enum of possible color values for use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.ColoredConsoleAppender"/>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Purple">
+            <summary>
+            color is purple
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.HighIntensity">
+            <summary>
+            color is intensified
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> together.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> suitable for 
+            setting the console color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.DebugAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the
+            debug system.
+            </para>
+            <para>
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(string,string)"/>
+            method. The event's logger name is passed as the value for the category name to the Write method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>
+            is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_category">
+            <summary>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.Category">
+            <summary>
+            Formats the category parameter sent to the Debug method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender">
+            <summary>
+            Writes events to the system event log.
+            </summary>
+            <remarks>
+            <para>
+            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.
+            See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog
+            </para>
+            <para>
+            The <c>EventID</c> of the event log entry can be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            The <c>Category</c> of the event log entry can be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            <para>
+            When configuring the EventLogAppender a mapping can be
+            specified to map a logging level to an event log entry type. For example:
+            </para>
+            <code lang="XML">
+            &lt;mapping&gt;
+            	&lt;level value="ERROR" /&gt;
+            	&lt;eventLogEntryType value="Error" /&gt;
+            &lt;/mapping&gt;
+            &lt;mapping&gt;
+            	&lt;level value="DEBUG" /&gt;
+            	&lt;eventLogEntryType value="Information" /&gt;
+            &lt;/mapping&gt;
+            </code>
+            <para>
+            The Level is the standard log4net logging level and eventLogEntryType can be any value
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:
+            <list type="bullet">
+            <item><term>Error</term><description>an error event</description></item>
+            <item><term>Warning</term><description>a warning event</description></item>
+            <item><term>Information</term><description>an informational event</description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Thomas Voss</author>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.
+            </summary>
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">
+            <summary>
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.
+            Each mapping defines the event log entry type for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">
+            <summary>
+            Create an event log source
+            </summary>
+            <remarks>
+            Uses different API calls under NET_2_0
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Writes the event to the system event log using the 
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>
+            
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            set then this integer will be used as the event log event id.</para>
+            
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">
+            <summary>
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/>
+            </summary>
+            <param name="level">the Level to convert to an EventLogEntryType</param>
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/></returns>
+            <remarks>
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
+            values to use in logging levels than there are in the 
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is
+            a loss of information during the conversion.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">
+            <summary>
+            The log name is the section in the event logs where the messages
+            are stored.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
+            <summary>
+            Name of the application to use when logging.  This appears in the
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
+            <summary>
+            The name of the machine which holds the event log. This is
+            currently only allowed to be '.' i.e. the current machine.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to EventLogEntryType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_eventId">
+            <summary>
+            The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_category">
+            <summary>
+            The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.declaringType">
+            <summary>
+            The fully qualified type of the EventLogAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_DEFAULT">
+            <summary>
+            The maximum size supported by default.
+            </summary>
+            <remarks>
+            http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx
+            The 32766 documented max size is two bytes shy of 32K (I'm assuming 32766 
+            may leave space for a two byte null terminator of #0#0). The 32766 max 
+            length is what the .NET 4.0 source code checks for, but this is WRONG! 
+            Strings with a length > 31839 on Windows Vista or higher can CORRUPT 
+            the event log! See: System.Diagnostics.EventLogInternal.InternalWriteEvent() 
+            for the use of the 32766 max size.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_VISTA_OR_NEWER">
+            <summary>
+            The maximum size supported by a windows operating system that is vista
+            or newer.
+            </summary>
+            <remarks>
+            See ReportEvent API:
+            	http://msdn.microsoft.com/en-us/library/aa363679(VS.85).aspx
+            ReportEvent's lpStrings parameter:
+            "A pointer to a buffer containing an array of 
+            null-terminated strings that are merged into the message before Event Viewer 
+            displays the string to the user. This parameter must be a valid pointer 
+            (or NULL), even if wNumStrings is zero. Each string is limited to 31,839 characters."
+            
+            Going beyond the size of 31839 will (at some point) corrupt the event log on Windows
+            Vista or higher! It may succeed for a while...but you will eventually run into the
+            error: "System.ComponentModel.Win32Exception : A device attached to the system is
+            not functioning", and the event log will then be corrupt (I was able to corrupt 
+            an event log using a length of 31877 on Windows 7).
+            
+            The max size for Windows Vista or higher is documented here:
+            	http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx.
+            Going over this size may succeed a few times but the buffer will overrun and 
+            eventually corrupt the log (based on testing).
+            
+            The maxEventMsgSize size is based on the max buffer size of the lpStrings parameter of the ReportEvent API.
+            The documented max size for EventLog.WriteEntry for Windows Vista and higher is 31839, but I'm leaving room for a
+            terminator of #0#0, as we cannot see the source of ReportEvent (though we could use an API monitor to examine the
+            buffer, given enough time).
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE">
+            <summary>
+            The maximum size that the operating system supports for
+            a event log message.
+            </summary>
+            <remarks>
+            Used to determine the maximum string length that can be written
+            to the operating system event log and eventually truncate a string
+            that exceeds the limits.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetMaxEventLogMessageSize">
+            <summary>
+            This method determines the maximum event log message size allowed for
+            the current environment.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.LogName">
+            <summary>
+            The name of the log where messages will be stored.
+            </summary>
+            <value>
+            The string name of the log where messages will be stored.
+            </value>
+            <remarks>
+            <para>This is the name of the log as it appears in the Event Viewer
+            tree. The default value is to log into the <c>Application</c>
+            log, this is where most applications write their events. However
+            if you need a separate log for your application (or applications)
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
+            <para>This should not be used to distinguish your event log messages
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
+            property should be used to distinguish events. This property should be 
+            used to group together events into a single log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
+            <summary>
+            Property used to set the Application name.  This appears in the
+            event logs when logging.
+            </summary>
+            <value>
+            The string used to distinguish events from different sources.
+            </value>
+            <remarks>
+            Sets the event log source property.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">
+            <summary>
+            This property is used to return the name of the computer to use
+            when accessing the event logs.  Currently, this is the current
+            computer, denoted by a dot "."
+            </summary>
+            <value>
+            The string name of the machine holding the event log that 
+            will be logged into.
+            </value>
+            <remarks>
+            This property cannot be changed. It is currently set to '.'
+            i.e. the local machine. This may be changed in future.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </value>
+            <remarks>
+            <para>
+            The system security context used to write to the EventLog.
+            </para>
+            <para>
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.EventId">
+            <summary>
+            Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>EventID</c> of the event log entry will normally be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Category">
+            <summary>
+            Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Category</c> of the event log entry will normally be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and its event log entry type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">
+            <summary>
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender">
+            <summary>
+            Appends logging events to a file.
+            </summary>
+            <remarks>
+            <para>
+            Logging events are sent to the file specified by
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.
+            </para>
+            <para>
+            The file can be opened in either append or overwrite mode 
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.
+            If the file path is relative it is taken as relative from 
+            the application base directory. The file encoding can be
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.
+            </para>
+            <para>
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            values will be written each time the file is opened and closed
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>
+            then the file may contain multiple copies of the header and footer.
+            </para>
+            <para>
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> 
+            is to obtain an exclusive write lock on the file until this appender is closed.
+            The alternative models only hold a
+            write lock while the appender is writing a logging event (<see cref="T:log4net.Appender.FileAppender.MinimalLock"/>)
+            or synchronize by using a named system wide Mutex (<see cref="T:log4net.Appender.FileAppender.InterProcessLock"/>).
+            </para>
+            <para>
+            All locking strategies have issues and you should seriously consider using a different strategy that
+            avoids having multiple processes logging to the same file.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Rodrigo B. de Oliveira</author>
+            <author>Douglas de la Torre</author>
+            <author>Niall Daley</author>
+        </member>
+        <member name="T:log4net.Appender.TextWriterAppender">
+            <summary>
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This appender may be used stand alone if initialized with an appropriate
+            writer, however it is typically used as a base class for an appender that
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized 
+            with the specified <see cref="T:System.IO.Stream"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender</param>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
+            <remarks>
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
+            <summary>
+            This method determines if there is a sense in attempting to append.
+            </summary>
+            <remarks>
+            <para>
+            This method checks if an output target has been set and if a
+            layout has been set. 
+            </para>
+            </remarks>
+            <returns><c>false</c> if any of the preconditions fail.</returns>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method writes all the bulk logged events to the output writer
+            before flushing the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+            <remarks>
+            Closed appenders cannot be reused.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
+            <summary>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">
+            <summary>
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> 
+            and other variables.
+            </summary>
+            <remarks>
+            <para>
+            Subclasses can override this method for an alternate closing behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
+            <summary>
+            Called to allow a subclass to lazily initialize the writer
+            </summary>
+            <remarks>
+            <para>
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
+            attempt to initialize the writer multiple times.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
+            <summary>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> 
+            or output stream will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logging events are not actually persisted if and when the application 
+            crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.declaringType">
+            <summary>
+            The fully qualified type of the TextWriterAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
+            <summary>
+            Gets or set whether the appender will flush at the end 
+            of each append operation.
+            </summary>
+            <value>
+            <para>
+            The default behavior is to flush at the end of each 
+            append operation.
+            </para>
+            <para>
+            If this option is set to <c>false</c>, then the underlying 
+            stream can defer persisting the logging event to a later 
+            time.
+            </para>
+            </value>
+            <remarks>
+            Avoiding the flush operation at the end of each append results in
+            a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">
+            <summary>
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
+            </summary>
+            <remarks>
+            <para>
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
+            </para>
+            <para>
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender 
+            instance is closed.
+            </para>
+            <para>
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
+            <summary>
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying 
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </value>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
+            </value>
+            <remarks>
+            <para>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
+            <summary>
+            Construct a new appender using the layout, file and append mode.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <param name="append">flag to indicate if the file should be appended to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
+            <summary>
+            Construct a new appender using the layout and file specified.
+            The file will be appended to.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
+            <summary>
+            Activate the options on the file appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This will cause the file to be opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Reset">
+            <summary>
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.
+            </summary>
+            <remarks>
+            <para>
+            Resets the filename and the file stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">
+            <summary>
+            Called to initialize the file writer
+            </summary>
+            <remarks>
+            <para>
+            Will be called for each logged message until the file is
+            successfully opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Acquires the output file locks once before writing all the events to
+            the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseFile">
+            <summary>
+            Closes the previously opened file.
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then
+            closes the file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            If there was already an opened file, then the previous file
+            is closed first.
+            </para>
+            <para>
+            This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">
+            <summary>
+            Sets the quiet writer used for file output
+            </summary>
+            <param name="fileStream">the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This implementation of <see cref="M:SetQWForFiles(Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>
+            over the <paramref name="fileStream"/> and passes it to the 
+            <see cref="M:SetQWForFiles(TextWriter)"/> method.
+            </para>
+            <para>
+            This method can be overridden by sub classes that want to wrap the
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <param name="writer">the writer over the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This method can be overridden by sub classes that want to
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
+            <summary>
+            Flag to indicate if we should append to the file
+            or overwrite the file. The default is to append.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_fileName">
+            <summary>
+            The name of the log file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_encoding">
+            <summary>
+            The encoding to use for the file stream.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_stream">
+            <summary>
+            The stream to log to. Has added locking semantics
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">
+            <summary>
+            The locking model to use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.declaringType">
+            <summary>
+            The fully qualified type of the FileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.File">
+            <summary>
+            Gets or sets the path to the file that logging will be written to.
+            </summary>
+            <value>
+            The path to the file that logging will be written to.
+            </value>
+            <remarks>
+            <para>
+            If the path is relative it is taken as relative from 
+            the application base directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">
+            <summary>
+            Gets or sets a flag that indicates whether the file should be
+            appended to or overwritten.
+            </summary>
+            <value>
+            Indicates whether the file should be appended to or overwritten.
+            </value>
+            <remarks>
+            <para>
+            If the value is set to false then the file will be overwritten, if 
+            it is set to true then the file will be appended to.
+            </para>
+            The default value is true.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>
+            which is the encoding for the system's current ANSI code page.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModel">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </para>
+            <para>
+            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"/> .
+            The first locks the file from the start of logging to the end, the 
+            second locks only for the minimal amount of time when logging each message
+            and the last synchronizes processes using a named system wide Mutex.
+            </para>
+            <para>
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingStream">
+            <summary>
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> 
+            to manage access to an underlying resource.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
+            <summary>
+            True asynchronous writes are not supported, the implementation forces a synchronous write.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LogException">
+            <summary>
+            Exception base type for log4net.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with
+            the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">
+            <summary>
+            Locking model base class
+            </summary>
+            <remarks>
+            <para>
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the output file
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CreateStream(System.String,System.Boolean,System.IO.FileShare)">
+            <summary>
+            Helper method that creates a FileStream under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            <para>
+            Typically called during OpenFile or AcquireLock. 
+            </para>
+            <para>
+            If the directory portion of the <paramref name="filename"/> does not exist, it is created
+            via Directory.CreateDirecctory.
+            </para>
+            </remarks>
+            <param name="filename"></param>
+            <param name="append"></param>
+            <param name="fileShare"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseStream(System.IO.Stream)">
+            <summary>
+            Helper method to close <paramref name="stream"/> under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            Does not set <paramref name="stream"/> to null.
+            </remarks>
+            <param name="stream"></param>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </summary>
+            <value>
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </value>
+            <remarks>
+            <para>
+            The file appender this locking model is attached to and working on
+            behalf of.
+            </para>
+            <para>
+            The file appender is used to locate the security context and the error handler to use.
+            </para>
+            <para>
+            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
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">
+            <summary>
+            Hold an exclusive lock on the output file
+            </summary>
+            <remarks>
+            <para>
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. 
+            Maintains an exclusive lock on the file during this time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Does nothing. The lock will be released when the file is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">
+            <summary>
+            Acquires the file lock for each write
+            </summary>
+            <remarks>
+            <para>
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, 
+            thus holding the lock for the minimal amount of time. This method of locking
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows 
+            other processes to move/delete the log file whilst logging continues.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Prepares to open the file when the first message is logged.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.InterProcessLock">
+            <summary>
+            Provides cross-process file locking.
+            </summary>
+            <author>Ron Grabowski</author>
+            <author>Steve Wranovsky</author>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/>,
+            -<see cref="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock">
+            <summary>
+            Releases the lock and allows others to acquire a lock.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ForwardingAppender">
+            <summary>
+            This appender forwards logging events to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The forwarding appender can be used to specify different thresholds
+            and filters for the same appender at different locations within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Forward the logging event to the attached appenders 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Forward the logging events to the attached appenders 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging events to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender">
+            <summary>
+            Logs events to a local syslog service.
+            </summary>
+            <remarks>
+            <note>
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.
+            If these functions are not available on the local system then this appender will not work!
+            </note>
+            <para>
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and 
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.
+            </para>
+            <para>
+            This appender talks to a local syslog service. If you need to log to a remote syslog
+            daemon and you cannot configure your local syslog service to do this you may be
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write 
+            to a local syslog service.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">
+            <summary>
+            Close the syslog when the appender is closed
+            </summary>
+            <remarks>
+            <para>
+            Close the syslog when the appender is closed
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">
+            <summary>
+            Marshaled handle to the identity string. We have to hold on to the
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the
+            pointer to the ident and dereference it for each log message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">
+            <summary>
+            Open connection to system logger.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">
+            <summary>
+            Generate a log message.
+            </summary>
+            <remarks>
+            <para>
+            The libc syslog method takes a format string and a variable argument list similar
+            to the classic printf function. As this type of vararg list is not supported
+            by C# we need to specify the arguments explicitly. Here we have specified the
+            format string with a single message argument. The caller must set the format 
+            string to <c>"%s"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">
+            <summary>
+            Close descriptor used to write to system logger.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The log4net Level maps to a syslog severity using the
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facility defines which subsystem the logging comes from.
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender">
+            <summary>
+            Appends colorful logging events to the console, using the .NET 2
+            built-in capabilities.
+            </summary>
+            <remarks>
+            <para>
+            ManagedColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            When configuring the colored console appender, mappings should be
+            specified to map logging levels to colors. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="DarkRed"/>
+            	<backColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="WARN"/>
+            	<foreColor value="Yellow"/>
+            </mapping>
+            <mapping>
+            	<level value="INFO"/>
+            	<foreColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<foreColor value="Blue"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level while
+            ForeColor and BackColor are the values of <see cref="T:System.ConsoleColor"/>
+            enumeration.
+            </para>
+            <para>
+            Based on the ColoredConsoleAppender
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+            <author>Pavlos Touboulidis</author>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.AddMapping(log4net.Appender.ManagedColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.MemoryAppender">
+            <summary>
+            Stores logging events in an array.
+            </summary>
+            <remarks>
+            <para>
+            The memory appender stores all the logging events
+            that are appended in an in-memory array.
+            </para>
+            <para>
+            Use the <see cref="M:PopAllEvents()"/> method to get
+            and clear the current list of events that have been appended.
+            </para>
+            <para>
+            Use the <see cref="M:GetEvents()"/> method to get the current
+            list of events that have been appended.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            <para>
+            Use the <see cref="M:Clear()"/> method to clear the
+            current list of events.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            </remarks>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">
+            <summary>
+            Gets the events that have been logged.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Clear">
+            <summary>
+            Clear the list of events
+            </summary>
+            <remarks>
+            Clear the list of events
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.PopAllEvents">
+            <summary>
+            Gets the events that have been logged and clears the list of events.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged and clears the list of events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
+            <summary>
+            The list of events that have been appended.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating whether only part of the logging event 
+            data should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the event 
+            data to be fixed and stored in the appender, hereby improving performance. 
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(bool)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.Fix">
+            <summary>
+            Gets or sets the fields that will be fixed in the event
+            </summary>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.NetSendAppender">
+            <summary>
+            Logs entries by sending network messages using the 
+            <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> native function.
+            </summary>
+            <remarks>
+            <para>
+            You can send messages only to names that are active 
+            on the network. If you send the message to a user name, 
+            that user must be logged on and running the Messenger 
+            service to receive the message.
+            </para>
+            <para>
+            The receiver will get a top most window displaying the 
+            messages one at a time, therefore this appender should 
+            not be used to deliver a high volume of messages.
+            </para>
+            <para>
+            The following table lists some possible uses for this appender :
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Action</term>
+                    <description>Property Value(s)</description>
+                </listheader>
+                <item>
+                    <term>Send a message to a user account on the local machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a user account on a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the remote machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a domain user account</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of a domain controller | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to all the names in a workgroup or domain</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;workgroup name | domain name&gt;*
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message from the local machine to a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;name of the remote machine&gt;
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            <b>Note :</b> security restrictions apply for sending 
+            network messages, see <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> 
+            for more information.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            An example configuration section to log information 
+            using this appender from the local machine, named 
+            LOCAL_PC, to machine OPERATOR_PC :
+            </para>
+            <code lang="XML" escaped="true">
+            <appender name="NetSendAppender_Operator" type="log4net.Appender.NetSendAppender">
+                <server value="LOCAL_PC"/>
+                <recipient value="OPERATOR_PC"/>
+                <layout type="log4net.Layout.PatternLayout" value="%-5p %c [%x] - %m%n"/>
+            </appender>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_server">
+            <summary>
+            The DNS or NetBIOS name of the server on which the function is to execute.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_sender">
+            <summary>
+            The sender of the network message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_recipient">
+            <summary>
+            The message alias to which the message should be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.#ctor">
+            <summary>
+            Initializes the appender.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was not specified.</exception>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using a network message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)">
+            <summary>
+            Sends a buffer of information to a registered message alias.
+            </summary>
+            <param name="serverName">The DNS or NetBIOS name of the server on which the function is to execute.</param>
+            <param name="msgName">The message alias to which the message buffer should be sent</param>
+            <param name="fromName">The originator of the message.</param>
+            <param name="buffer">The message text.</param>
+            <param name="bufferSize">The length, in bytes, of the message text.</param>
+            <remarks>
+            <para>
+            The following restrictions apply for sending network messages:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Platform</term>
+                    <description>Requirements</description>
+                </listheader>
+                <item>
+                    <term>Windows NT</term>
+                    <description>
+                        <para>
+                        No special group membership is required to send a network message.
+                        </para>
+                        <para>
+                        Admin, Accounts, Print, or Server Operator group membership is required to 
+                        successfully send a network message on a remote server.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Windows 2000 or later</term>
+                    <description>
+                        <para>
+                        If you send a message on a domain controller that is running Active Directory, 
+                        access is allowed or denied based on the access control list (ACL) for the securable 
+                        object. The default ACL permits only Domain Admins and Account Operators to send a network message. 
+                        </para>
+                        <para>
+                        On a member server or workstation, only Administrators and Server Operators can send a network message. 
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            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>.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is zero.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Sender">
+            <summary>
+            Gets or sets the sender of the message.
+            </summary>
+            <value>
+            The sender of the message.
+            </value>
+            <remarks>
+            If this property is not specified, the message is sent from the local computer.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Recipient">
+            <summary>
+            Gets or sets the message alias to which the message should be sent.
+            </summary>
+            <value>
+            The recipient of the message.
+            </value>
+            <remarks>
+            This property should always be specified in order to send a message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Server">
+            <summary>
+            Gets or sets the DNS or NetBIOS name of the remote server on which the function is to execute.
+            </summary>
+            <value>
+            DNS or NetBIOS name of the remote server on which the function is to execute.
+            </value>
+            <remarks>
+            <para>
+            For Windows NT 4.0 and earlier, the string should begin with \\.
+            </para>
+            <para>
+            If this property is not specified, the local computer is used. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.OutputDebugStringAppender">
+            <summary>
+            Appends log events to the OutputDebugString system.
+            </summary>
+            <remarks>
+            <para>
+            OutputDebugStringAppender appends log events to the
+            OutputDebugString system.
+            </para>
+            <para>
+            The string is passed to the native <c>OutputDebugString</c> 
+            function.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.OutputDebugStringAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the output debug string API
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the output debug string API
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">
+            <summary>
+            Stub for OutputDebugString native method
+            </summary>
+            <param name="message">the string to output</param>
+            <remarks>
+            <para>
+            Stub for OutputDebugString native method
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.OutputDebugStringAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender">
+            <summary>
+            Logs events to a remote syslog daemon.
+            </summary>
+            <remarks>
+            <para>
+            The BSD syslog protocol is used to remotely log to
+            a syslog daemon. The syslogd listens for for messages
+            on UDP port 514.
+            </para>
+            <para>
+            The syslog UDP protocol is not authenticated. Most syslog daemons
+            do not accept remote log messages because of the security implications.
+            You may be able to use the LocalSyslogAppender to talk to a local
+            syslog service.
+            </para>
+            <para>
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.
+            This appender generates what the RFC calls an "Original Device Message",
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation
+            this format of message will be accepted by all current syslog daemon
+            implementations. The daemon will attach the current time and the source
+            hostname or IP address to any messages received.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Appender.UdpAppender">
+             <summary>
+             Sends logging events as connectionless UDP datagrams to a remote host or a 
+             multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.
+             </summary>
+             <remarks>
+             <para>
+             UDP guarantees neither that messages arrive, nor that they arrive in the correct order.
+             </para>
+             <para>
+             To view the logging results, a custom application can be developed that listens for logging 
+             events.
+             </para>
+             <para>
+             When decoding events send via this appender remember to use the same encoding
+             to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>
+             property to specify the encoding to use.
+             </para>
+             </remarks>
+             <example>
+             This example shows how to log receive logging events that are sent 
+             on IP address 244.0.0.1 and port 8080 to the console. The event is 
+             encoded in the packet as a unicode string and it is decoded as such. 
+             <code lang="C#">
+             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+             UdpClient udpClient;
+             byte[] buffer;
+             string loggingEvent;
+             
+             try 
+             {
+                 udpClient = new UdpClient(8080);
+                 
+                 while(true) 
+                 {
+                     buffer = udpClient.Receive(ref remoteEndPoint);
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
+                     Console.WriteLine(loggingEvent);
+                 }
+             } 
+             catch(Exception e) 
+             {
+                 Console.WriteLine(e.ToString());
+             }
+             </code>
+             <code lang="Visual Basic">
+             Dim remoteEndPoint as IPEndPoint
+             Dim udpClient as UdpClient
+             Dim buffer as Byte()
+             Dim loggingEvent as String
+             
+             Try 
+                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
+                 udpClient = new UdpClient(8080)
+            
+                 While True
+                     buffer = udpClient.Receive(ByRef remoteEndPoint)
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
+                     Console.WriteLine(loggingEvent)
+                 Wend
+             Catch e As Exception
+                 Console.WriteLine(e.ToString())
+             End Try
+             </code>
+             <para>
+             An example configuration section to log information using this appender to the 
+             IP 224.0.0.1 on port 8080:
+             </para>
+             <code lang="XML" escaped="true">
+             <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
+                 <remoteAddress value="224.0.0.1"/>
+                 <remotePort value="8080"/>
+                 <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>
+             </appender>
+             </code>
+             </example>
+             <author>Gert Driesen</author>
+             <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or 
+            an invalid remote or local TCP port number was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>
+            <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>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using an UDP datagram.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.OnClose">
+            <summary>
+            Closes the UDP connection and releases all resources associated with 
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed 
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">
+            <summary>
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.
+            </summary>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the 
+            port number from which you intend to communicate.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">
+            <summary>
+            The IP address of the remote host or multicast group to which 
+            the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">
+            <summary>
+            The TCP port number of the remote host or multicast group to 
+            which the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">
+            <summary>
+            The cached remote endpoint to which the logging events will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">
+            <summary>
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_client">
+            <summary>
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the 
+            logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">
+            <summary>
+            The encoding to use for the packet.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">
+            <summary>
+            Gets or sets the IP address of the remote host or multicast group to which
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            The IP address of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            <para>
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so
+            it is possible to use multicasts in an Internet scenario as long as your network provider 
+            supports multicasting.
+            </para>
+            <para>
+            Hosts that want to receive particular multicast messages must register their interest by joining
+            the multicast group.  Multicast messages are not sent to networks where no host has joined
+            the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
+            them from normal host addresses, allowing nodes to easily detect if a message is of interest.
+            </para>
+            <para>
+            Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>IP Address</term>
+                    <description>Description</description>
+                </listheader>
+                <item>
+                    <term>224.0.0.1</term>
+                    <description>
+                        <para>
+                        Sends a message to all system on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.2</term>
+                    <description>
+                        <para>
+                        Sends a message to all routers on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.12</term>
+                    <description>
+                        <para>
+                        The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            A complete list of actually reserved multicast addresses and their owners in the ranges
+            defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
+            </para>
+            <para>
+            The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
+            addresses.  These addresses can be reused with other local groups.  Routers are typically 
+            configured with filters to prevent multicast traffic in this range from flowing outside
+            of the local network.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemotePort">
+            <summary>
+            Gets or sets the TCP port number of the remote host or multicast group to which 
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will send messages to this TCP port number
+            on the remote host or multicast group.
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.LocalPort">
+            <summary>
+            Gets or sets the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </value>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will bind to this port for sending messages.
+            </para>
+            <para>
+            Setting the value to 0 (the default) will cause the udp client not to bind to
+            a local port.
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Client">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.UdpAppender"/> creates a <see cref="T:System.Net.Sockets.UdpClient"/> to send logging events 
+            over a network.  Classes deriving from <see cref="T:log4net.Appender.UdpAppender"/> can use this
+            property to get or set this <see cref="T:System.Net.Sockets.UdpClient"/>.  Use the underlying <see cref="T:System.Net.Sockets.UdpClient"/>
+            returned from <see cref="P:log4net.Appender.UdpAppender.Client"/> if you require access beyond that which 
+            <see cref="T:log4net.Appender.UdpAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteEndPoint">
+            <summary>
+            Gets or sets the cached remote endpoint to which the logging events should be sent.
+            </summary>
+            <value>
+            The cached remote endpoint to which the logging events will be sent.
+            </value>
+            <remarks>
+            The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method will initialize the remote endpoint 
+            with the values of the <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> and <see cref="P:log4net.Appender.UdpAppender.RemotePort"/>
+            properties.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.DefaultSyslogPort">
+            <summary>
+            Syslog port 514
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class is set up to write 
+            to a remote syslog daemon.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.AddMapping(log4net.Appender.RemoteSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity"/> mapping to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to syslog severity mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GeneratePriority(log4net.Appender.RemoteSyslogAppender.SyslogFacility,log4net.Appender.RemoteSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+            <remarks>
+            <para>
+            Generate a syslog priority.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The syslog severities.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facilities
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender">
+            <summary>
+            Delivers logging events to a remote logging sink. 
+            </summary>
+            <remarks>
+            <para>
+            This Appender is designed to deliver events to a remote sink. 
+            That is any object that implements the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface. It delivers the events using .NET remoting. The
+            object to deliver events to is specified by setting the
+            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.</para>
+            <para>
+            The RemotingAppender buffers events before sending them. This allows it to 
+            make more efficient use of the remoting infrastructure.</para>
+            <para>
+            Once the buffer is full the events are still not sent immediately. 
+            They are scheduled to be sent using a pool thread. The effect is that 
+            the send occurs asynchronously. This is very important for a 
+            number of non obvious reasons. The remoting infrastructure will 
+            flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.</para>
+            <para>
+            Because the events are sent asynchronously using pool threads it is possible to close 
+            this appender before all the queued events have been sent.
+            When closing the appender attempts to wait until all the queued events have been sent, but 
+            this will timeout after 30 seconds regardless.</para>
+            <para>
+            If this appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for. If the runtime terminates the threads before
+            the queued events have been sent then they will be lost. To ensure that all events
+            are sent the appender must be closed before the application exits. See 
+            <see cref="M:log4net.Core.LoggerManager.Shutdown"/> for details on how to shutdown
+            log4net programmatically.</para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemotingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            The events are not sent immediately. They are scheduled to be sent
+            using a pool thread. The effect is that the send occurs asynchronously.
+            This is very important for a number of non obvious reasons. The remoting
+            infrastructure will flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.
+            </remarks>
+            <param name="events">The events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.OnClose">
+            <summary>
+            Override base class close.
+            </summary>
+            <remarks>
+            <para>
+            This method waits while there are queued work items. The events are
+            sent asynchronously using <see cref="T:System.Threading.ThreadPool"/> work items. These items
+            will be sent once a thread pool thread is available to send them, therefore
+            it is possible to close the appender before all the queued events have been
+            sent.</para>
+            <para>
+            This method attempts to wait until all the queued events have been sent, but this 
+            method will timeout after 30 seconds regardless.</para>
+            <para>
+            If the appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.BeginAsyncSend">
+            <summary>
+            A work item is being queued into the thread pool
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.EndAsyncSend">
+            <summary>
+            A work item from the thread pool has completed
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBufferCallback(System.Object)">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            This method is designed to be used with the <see cref="T:System.Threading.ThreadPool"/>.
+            This method expects to be passed an array of <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the state param.
+            </remarks>
+            <param name="state">the logging events to send</param>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">
+            <summary>
+            The URL of the remote sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">
+            <summary>
+            The local proxy (.NET remoting) for the remote logging sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_queuedCallbackCount">
+            <summary>
+            The number of queued callbacks currently waiting or executing
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_workQueueEmptyEvent">
+            <summary>
+            Event used to signal when there are no queued work items
+            </summary>
+            <remarks>
+            This event is set when there are no queued work items. In this
+            state it is safe to close the appender.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemotingAppender.Sink">
+            <summary>
+            Gets or sets the URL of the well-known object that will accept 
+            the logging events.
+            </summary>
+            <value>
+            The well-known URL of the remote sink.
+            </value>
+            <remarks>
+            <para>
+            The URL of the remoting sink that will accept logging events.
+            The sink must implement the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink">
+            <summary>
+            Interface used to deliver <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            This interface must be implemented by a remoting sink
+            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used
+            to deliver logging events to the sink.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.IRemoteLoggingSink.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Delivers logging events to the remote sink
+            </summary>
+            <param name="events">Array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers logging events to the remote sink
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender">
+            <summary>
+            Appender that rolls log files based on size or date or both.
+            </summary>
+            <remarks>
+            <para>
+            RollingFileAppender can roll log files based on size or date or both
+            depending on the setting of the <see cref="P:log4net.Appender.RollingFileAppender.RollingStyle"/> property.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Size"/> the log file will be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Date"/> the log file will be rolled
+            once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/> the log file will be
+            rolled once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed, but within a date boundary the file will also be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> the log file will be rolled when
+            the appender is configured. This effectively means that the log file can be
+            rolled once per program execution.
+            </para>
+            <para>
+            A of few additional optional features have been added:
+            <list type="bullet">
+            <item>Attach date pattern for current log file <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/></item>
+            <item>Backup number increments for newer files <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/></item>
+            <item>Infinite number of backups by file size <see cref="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups"/></item>
+            </list>
+            </para>
+            
+            <note>
+            <para>
+            For large or infinite numbers of backup files a <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> 
+            greater than zero is highly recommended, otherwise all the backup files need
+            to be renamed each time a new backup is created.
+            </para>
+            <para>
+            When Date/Time based rolling is used setting <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> 
+            to <see langword="true"/> will reduce the number of file renamings to few or none.
+            </para>
+            </note>
+            
+            <note type="caution">
+            <para>
+            Changing <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> or <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> without clearing
+            the log file directory of backup files will cause unexpected and unwanted side effects.  
+            </para>
+            </note>
+            
+            <para>
+            If Date/Time based rolling is enabled this appender will attempt to roll existing files
+            in the directory without a Date/Time tag based on the last write date of the base log file.
+            The appender only rolls the log file when a message is logged. If Date/Time based rolling 
+            is enabled then the appender will not roll the log file at the Date/Time boundary but
+            at the point when the next message is logged after the boundary has been crossed.
+            </para>
+            
+            <para>
+            The <see cref="T:log4net.Appender.RollingFileAppender"/> extends the <see cref="T:log4net.Appender.FileAppender"/> and
+            has the same behavior when opening the log file.
+            The appender will first try to open the file for writing when <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            When rolling a backup file necessitates deleting an older backup file the
+            file to be deleted is moved to a temporary name before being deleted.
+            </para>
+            
+            <note type="caution">
+            <para>
+            A maximum number of backup files when rolling on date/time boundaries is not supported.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Edward Smit</author>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RollingFileAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Finalize">
+            <summary>
+            Cleans up all resources used by this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.declaringType">
+            <summary>
+            The fully qualified type of the RollingFileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <remarks>
+            This method can be overridden by sub classes.
+            </remarks>
+            <param name="writer">the writer to set</param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write out a logging event.
+            </summary>
+            <param name="loggingEvent">the event to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Write out an array of logging events.
+            </summary>
+            <param name="loggingEvents">the events to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.AdjustFileBeforeAppend">
+            <summary>
+            Performs any required rolling before outputting the next event
+            </summary>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Creates and opens the file for logging.  If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/>
+            is false then the fully qualified name is determined and used.
+            </summary>
+            <param name="fileName">the name of the file to open</param>
+            <param name="append">true to append to existing file</param>
+            <remarks>
+            <para>This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetNextOutputFileName(System.String)">
+            <summary>
+            Get the current output file name
+            </summary>
+            <param name="fileName">the base file name</param>
+            <returns>the output file name</returns>
+            <remarks>
+            The output file name is based on the base fileName specified.
+            If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> is set then the output 
+            file name is the same as the base file passed in. Otherwise
+            the output file depends on the date pattern, on the count
+            direction or both.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DetermineCurSizeRollBackups">
+            <summary>
+            Determines curSizeRollBackups (only within the current roll point)
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">
+            <summary>
+            Generates a wildcard pattern that can be used to find all files
+            that are similar to the base file name.
+            </summary>
+            <param name="baseFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">
+            <summary>
+            Builds a list of filenames for all files matching the base filename plus a file
+            pattern.
+            </summary>
+            <param name="baseFilePath"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">
+            <summary>
+            Initiates a roll over if needed for crossing a date boundary since the last run.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">
+            <summary>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            </summary>
+            <remarks>
+            <para>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            The following is done
+            <list type="bullet">
+            <item>determine curSizeRollBackups (only within the current roll point)</item>
+            <item>initiates a roll over if needed for crossing a date boundary since the last run.</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">
+            <summary>
+            Does the work of bumping the 'current' file counter higher
+            to the highest count when an incremental file name is seen.
+            The highest count is either the first file (when count direction
+            is greater than 0) or the last file (when count direction less than 0).
+            In either case, we want to know the highest count that is present.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="curFileName"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetBackUpIndex(System.String)">
+            <summary>
+            Attempts to extract a number from the end of the file name that indicates
+            the number of the times the file has been rolled over.
+            </summary>
+            <remarks>
+            Certain date pattern extensions like yyyyMMdd will be parsed as valid backup indexes.
+            </remarks>
+            <param name="curFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">
+            <summary>
+            Takes a list of files and a base file name, and looks for 
+            'incremented' versions of the base file.  Bumps the max
+            count up to the highest count seen.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="arrayFiles"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod(System.String)">
+            <summary>
+            Calculates the RollPoint for the datePattern supplied.
+            </summary>
+            <param name="datePattern">the date pattern to calculate the check period for</param>
+            <returns>The RollPoint that is most accurate for the date pattern supplied</returns>
+            <remarks>
+            Essentially the date pattern is examined to determine what the
+            most suitable roll point is. The roll point chosen is the roll point
+            with the smallest period that can be detected using the date pattern
+            supplied. i.e. if the date pattern only outputs the year, month, day 
+            and hour then the smallest roll point that can be detected would be
+            and hourly roll point as minutes could not be detected.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Sets initial conditions including date/time roll over information, first check,
+            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize
+            the current number of backups.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.CombinePath(System.String,System.String)">
+            <summary>
+            
+            </summary>
+            <param name="path1"></param>
+            <param name="path2">.1, .2, .3, etc.</param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime(System.Boolean)">
+            <summary>
+            Rollover the file(s) to date/time tagged file(s).
+            </summary>
+            <param name="fileIsOpen">set to true if the file to be rolled is currently open</param>
+            <remarks>
+            <para>
+            Rollover the file(s) to date/time tagged file(s).
+            Resets curSizeRollBackups. 
+            If fileIsOpen is set then the new file is opened (through SafeOpenFile).
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">
+            <summary>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>.
+            </summary>
+            <param name="fromFile">Name of existing file to roll.</param>
+            <param name="toFile">New name for file.</param>
+            <remarks>
+            <para>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. It
+            also checks for existence of target file and deletes if it does.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.FileExists(System.String)">
+            <summary>
+            Test if a file exists at a specified path
+            </summary>
+            <param name="path">the path to the file</param>
+            <returns>true if the file exists</returns>
+            <remarks>
+            <para>
+            Test if a file exists at a specified path
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">
+            <summary>
+            Deletes the specified file if it exists.
+            </summary>
+            <param name="fileName">The file to delete.</param>
+            <remarks>
+            <para>
+            Delete a file if is exists.
+            The file is first moved to a new filename then deleted.
+            This allows the file to be removed even when it cannot
+            be deleted, but it still can be moved.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">
+            <summary>
+            Implements file roll base on file size.
+            </summary>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. Moreover, <c>File</c> is
+            renamed <c>File.1</c> and closed.
+            </para>
+            <para>
+            A new file is created to receive further log output.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverRenameFiles(System.String)">
+            <summary>
+            Implements file roll.
+            </summary>
+            <param name="baseFileName">the base name to rename</param>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. 
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            <para>
+            This is called by <see cref="M:log4net.Appender.RollingFileAppender.RollOverSize"/> to rename the files.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">
+            <summary>
+            Get the start time of the next window for the current rollpoint
+            </summary>
+            <param name="currentDateTime">the current date</param>
+            <param name="rollPoint">the type of roll point we are working with</param>
+            <returns>the start time for the next roll point an interval after the currentDateTime date</returns>
+            <remarks>
+            <para>
+            Returns the date of the next roll point after the currentDateTime date passed to the method.
+            </para>
+            <para>
+            The basic strategy is to subtract the time parts that are less significant
+            than the rollpoint from the current time. This should roll the time back to
+            the start of the time window for the current rollpoint. Then we add 1 window
+            worth of time and get the start time of the next window for the rollpoint.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">
+            <summary>
+            This object supplies the current date/time.  Allows test code to plug in
+            a method to control this class when testing date/time based rolling. The default
+            implementation uses the underlying value of DateTime.Now.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">
+            <summary>
+            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> 
+            meaning daily rollover.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">
+            <summary>
+            The actual formatted filename that is currently being written to
+            or will be the file transferred to on roll over
+            (based on staticLogFileName).
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">
+            <summary>
+            The timestamp when we shall next recompute the filename.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_now">
+            <summary>
+            Holds date of last roll over
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">
+            <summary>
+            The type of rolling done
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">
+            <summary>
+            The default maximum file size is 10MB
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">
+            <summary>
+            There is zero backup files by default
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">
+            <summary>
+            How many sized based backups have been made so far
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">
+            <summary>
+            The rolling file count direction. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">
+            <summary>
+            The rolling mode used in this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">
+            <summary>
+            Cache flag set if we are rolling by date.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">
+            <summary>
+            Cache flag set if we are rolling by size.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">
+            <summary>
+            Value indicating whether to always log to the same file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_preserveLogFileNameExtension">
+            <summary>
+            Value indicating whether to preserve the file name extension when rolling.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">
+            <summary>
+            FileName provided in configuration.  Used for rolling properly
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_mutexForRolling">
+            <summary>
+            A mutex that is used to lock rolling of files.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DateTimeStrategy">
+            <summary>
+            Gets or sets the strategy for determining the current date and time. The default
+            implementation is to use LocalDateTime which internally calls through to DateTime.Now. 
+            DateTime.UtcNow may be used on frameworks newer than .NET 1.0 by specifying
+            <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </summary>
+            <value>
+            An implementation of the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> interface which returns the current date and time.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> used to return the current date and time.
+            </para>
+            <para>
+            There are two built strategies for determining the current date and time, 
+            <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>
+            and <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </para>
+            <para>
+            The default strategy is <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">
+            <summary>
+            Gets or sets the date pattern to be used for generating file names
+            when rolling over on date.
+            </summary>
+            <value>
+            The date pattern to be used for generating file names when rolling 
+            over on date.
+            </value>
+            <remarks>
+            <para>
+            Takes a string in the same format as expected by 
+            <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.
+            </para>
+            <para>
+            This property determines the rollover schedule when rolling over
+            on date.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">
+            <summary>
+            Gets or sets the maximum number of backup files that are kept before
+            the oldest is erased.
+            </summary>
+            <value>
+            The maximum number of backup files that are kept before the oldest is
+            erased.
+            </value>
+            <remarks>
+            <para>
+            If set to zero, then there will be no backup files and the log file 
+            will be truncated when it reaches <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  
+            </para>
+            <para>
+            If a negative number is supplied then no deletions will be made.  Note 
+            that this could result in very slow performance as a large number of 
+            files are rolled over unless <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> is used.
+            </para>
+            <para>
+            The maximum applies to <b>each</b> time based group of files and 
+            <b>not</b> the total.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size in bytes that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except
+            that it is required for differentiating the setter taking a
+            <see cref="T:System.Int64"/> argument from the setter taking a <see cref="T:System.String"/> 
+            argument.
+            </para>
+            <para>
+            The default maximum file size is 10MB (10*1024*1024).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property allows you to specify the maximum size with the
+            suffixes "KB", "MB" or "GB" so that the size is interpreted being 
+            expressed respectively in kilobytes, megabytes or gigabytes. 
+            </para>
+            <para>
+            For example, the value "10KB" will be interpreted as 10240 bytes.
+            </para>
+            <para>
+            The default maximum file size is 10MB.
+            </para>
+            <para>
+            If you have the option to set the maximum file size programmatically
+            consider using the <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/> property instead as this
+            allows you to set the size in bytes as a <see cref="T:System.Int64"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">
+            <summary>
+            Gets or sets the rolling file count direction. 
+            </summary>
+            <value>
+            The rolling file count direction.
+            </value>
+            <remarks>
+            <para>
+            Indicates if the current file is the lowest numbered file or the
+            highest numbered file.
+            </para>
+            <para>
+            By default newer files have lower numbers (<see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &lt; 0),
+            i.e. log.1 is most recent, log.5 is the 5th backup, etc...
+            </para>
+            <para>
+            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 does the opposite i.e.
+            log.1 is the first backup made, log.5 is the 5th backup made, etc.
+            For infinite backups use <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 to reduce 
+            rollover costs.
+            </para>
+            <para>The default file count direction is -1.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">
+            <summary>
+            Gets or sets the rolling style.
+            </summary>
+            <value>The rolling style.</value>
+            <remarks>
+            <para>
+            The default rolling style is <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/>.
+            </para>
+            <para>
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> this appender's
+            <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is set to <c>false</c>, otherwise
+            the appender would append to a single file rather than rolling
+            the file each time it is opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.PreserveLogFileNameExtension">
+            <summary>
+            Gets or sets a value indicating whether to preserve the file name extension when rolling.
+            </summary>
+            <value>
+            <c>true</c> if the file name extension should be preserved.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is rolled to file.log.yyyy-MM-dd or file.log.curSizeRollBackup.
+            However, under Windows the new file name will loose any program associations as the
+            extension is changed. Optionally file.log can be renamed to file.yyyy-MM-dd.log or
+            file.curSizeRollBackup.log to maintain any program associations.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">
+            <summary>
+            Gets or sets a value indicating whether to always log to
+            the same file.
+            </summary>
+            <value>
+            <c>true</c> if always should be logged to the same file, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is always the current file.  Optionally
+            file.log.yyyy-mm-dd for current formatted datePattern can by the currently
+            logging file (or file.log.curSizeRollBackup or even
+            file.log.yyyy-mm-dd.curSizeRollBackup).
+            </para>
+            <para>
+            This will make time based rollovers with a large number of backups 
+            much faster as the appender it won't have to rename all the backups!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">
+            <summary>
+            Style of rolling to use
+            </summary>
+            <remarks>
+            <para>
+            Style of rolling to use
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Once">
+            <summary>
+            Roll files once per program execution
+            </summary>
+            <remarks>
+            <para>
+            Roll files once per program execution.
+            Well really once each time this appender is
+            configured.
+            </para>
+            <para>
+            Setting this option also sets <c>AppendToFile</c> to
+            <c>false</c> on the <c>RollingFileAppender</c>, otherwise
+            this appender would just be a normal file appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">
+            <summary>
+            Roll files based only on the size of the file
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">
+            <summary>
+            Roll files based only on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">
+            <summary>
+            Roll files based on both the size and date of the file
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">
+            <summary>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </summary>
+            <remarks>
+            <para>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.InvalidRollPoint">
+            <summary>
+            Roll the log not based on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMinute">
+            <summary>
+            Roll the log for each minute
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfHour">
+            <summary>
+            Roll the log for each hour
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HalfDay">
+            <summary>
+            Roll the log twice a day (midday and midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfDay">
+            <summary>
+            Roll the log each day (midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfWeek">
+            <summary>
+            Roll the log each week
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMonth">
+            <summary>
+            Roll the log each month
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.IDateTime">
+            <summary>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            </summary>
+            <remarks>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            Used primarily to allow test classes to plug themselves in so they can
+            supply test date/times.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.IDateTime.Now">
+            <summary>
+            Gets the <i>current</i> time.
+            </summary>
+            <value>The <i>current</i> time.</value>
+            <remarks>
+            <para>
+            Gets the <i>current</i> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.LocalDateTime">
+            <summary>
+            Default implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.LocalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.UniversalDateTime">
+            <summary>
+            Implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time as the coordinated universal time (UTC).
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.UniversalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender">
+            <summary>
+            Send an e-mail when a specific logging event occurs, typically on errors 
+            or fatal errors.
+            </summary>
+            <remarks>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            <note type="caution">
+            Authentication and setting the server Port are only available on the MS .NET 1.1 runtime.
+            For these features to be enabled you need to ensure that you are using a version of
+            the log4net assembly that is built against the MS .NET 1.1 framework and that you are
+            running the your application on the MS .NET 1.1 runtime. On all other platforms only sending
+            unauthenticated messages to a server listening on port 25 (the default) is supported.
+            </note>
+            <para>
+            Authentication is supported by setting the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property to
+            either <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> or <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>.
+            If using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> authentication then the <see cref="P:log4net.Appender.SmtpAppender.Username"/>
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> properties must also be set.
+            </para>
+            <para>
+            To set the SMTP server port use the <see cref="P:log4net.Appender.SmtpAppender.Port"/> property. The default port is 25.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendEmail(System.String)">
+            <summary>
+            Send the email message
+            </summary>
+            <param name="messageBody">the body text to include in the mail</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.MaybeTrimSeparators(System.String)">
+            <summary>
+              trims leading and trailing commas or semicolons
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.To">
+            <summary>
+            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).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Cc">
+            <summary>
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses 
+            that will be carbon copied (use semicolon on .NET 1.1 and comma for later versions).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Bcc">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses
+            that will be blind carbon copied.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of recipient e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SmtpHost">
+            <summary>
+            Gets or sets the name of the SMTP relay mail server to use to send 
+            the e-mail messages.
+            </summary>
+            <value>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </value>
+            <remarks>
+            <para>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.LocationInfo">
+            <summary>
+            Obsolete
+            </summary>
+            <remarks>
+            Use the BufferingAppenderSkeleton Fix methods instead 
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Authentication">
+            <summary>
+            The mode to use to authentication with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            Valid Authentication mode values are: <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>, 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, and <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>. 
+            The default value is <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>. When using 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> you must specify the <see cref="P:log4net.Appender.SmtpAppender.Username"/> 
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> to use to authenticate.
+            When using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/> the Windows credentials for the current
+            thread, if impersonating, or the process will be used to authenticate. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Username">
+            <summary>
+            The username to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the username will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Password">
+            <summary>
+            The password to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the password will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Port">
+            <summary>
+            The port on which the SMTP server is listening
+            </summary>
+            <remarks>
+            <note type="caution">Server Port is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            The port on which the SMTP server is listening. The default
+            port is <c>25</c>. The Port can only be changed when running on
+            the MS .NET 1.1 runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Priority">
+            <summary>
+            Gets or sets the priority of the e-mail message
+            </summary>
+            <value>
+            One of the <see cref="T:System.Net.Mail.MailPriority"/> values.
+            </value>
+            <remarks>
+            <para>
+            Sets the priority of the e-mails generated by this
+            appender. The default priority is <see cref="F:System.Net.Mail.MailPriority.Normal"/>.
+            </para>
+            <para>
+            If you are using this appender to report errors then
+            you may want to set the priority to <see cref="F:System.Net.Mail.MailPriority.High"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.EnableSsl">
+            <summary>
+            Enable or disable use of SSL when sending e-mail message
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.ReplyTo">
+            <summary>
+            Gets or sets the reply-to e-mail address.
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SubjectEncoding">
+            <summary>
+            Gets or sets the subject encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.BodyEncoding">
+            <summary>
+            Gets or sets the body encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender.SmtpAuthentication">
+            <summary>
+            Values for the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property.
+            </summary>
+            <remarks>
+            <para>
+            SMTP authentication modes.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None">
+            <summary>
+            No authentication
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic">
+            <summary>
+            Basic authentication.
+            </summary>
+            <remarks>
+            Requires a username and password to be supplied
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm">
+            <summary>
+            Integrated authentication
+            </summary>
+            <remarks>
+            Uses the Windows credentials from the current thread or process to authenticate.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpPickupDirAppender">
+            <summary>
+            Send an email when a specific logging event occurs, typically on errors 
+            or fatal errors. Rather than sending via smtp it writes a file into the
+            directory specified by <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>. This allows services such
+            as the IIS SMTP agent to manage sending the messages.
+            </summary>
+            <remarks>
+            <para>
+            The configuration for this appender is identical to that of the <c>SMTPAppender</c>,
+            except that instead of specifying the <c>SMTPAppender.SMTPHost</c> you specify
+            <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>.
+            </para>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpPickupDirAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            </remarks>
+            <author>Niall Daley</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+            <remarks>
+            <para>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions">
+            <summary>
+            Activate the options on this appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpPickupDirAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.To">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.PickupDir">
+            <summary>
+            Gets or sets the path to write the messages to.
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the path to write the messages to. This should be the same
+            as that used by the agent sending the messages.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.FileExtension">
+            <summary>
+            Gets or sets the file extension for the generated files
+            </summary>
+            <value>
+            The file extension for the generated files
+            </value>
+            <remarks>
+            <para>
+            The file extension for the generated files
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender">
+            <summary>
+            Appender that allows clients to connect via Telnet to receive log messages
+            </summary>
+            <remarks>	
+            <para>
+            The TelnetAppender accepts socket connections and streams logging messages
+            back to the client.  
+            The output is provided in a telnet-friendly way so that a log can be monitored 
+            over a TCP/IP socket.
+            This allows simple remote monitoring of application logging.
+            </para>
+            <para>
+            The default <see cref="P:log4net.Appender.TelnetAppender.Port"/> is 23 (the telnet port).
+            </para>
+            </remarks>
+            <author>Keith Long</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TelnetAppender.declaringType">
+            <summary>
+            The fully qualified type of the TelnetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.OnClose">
+            <summary>
+            Overrides the parent method to close the socket handler
+            </summary>
+            <remarks>
+            <para>
+            Closes all the outstanding connections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Create the socket handler and wait for connections
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to each connected client.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to each connected client.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.Port">
+            <summary>
+            Gets or sets the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </value>
+            <remarks>
+            <para>
+            The default value is 23 (the telnet port).
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler">
+            <summary>
+            Helper class to manage connected clients
+            </summary>
+            <remarks>
+            <para>
+            The SocketHandler class is used to accept connections from
+            clients.  It is threaded so that clients can connect/disconnect
+            asynchronously.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.#ctor(System.Int32)">
+            <summary>
+            Opens a new server port on <paramref ref="port"/>
+            </summary>
+            <param name="port">the local port to listen on for connections</param>
+            <remarks>
+            <para>
+            Creates a socket handler on the specified local server port.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Send(System.String)">
+            <summary>
+            Sends a string message to each of the connected clients
+            </summary>
+            <param name="message">the text to send</param>
+            <remarks>
+            <para>
+            Sends a string message to each of the connected clients
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.AddClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Add a client to the internal clients list
+            </summary>
+            <param name="client">client to add</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.RemoveClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Remove a client from the internal clients list
+            </summary>
+            <param name="client">client to remove</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.OnConnect(System.IAsyncResult)">
+            <summary>
+            Callback used to accept a connection on the server socket
+            </summary>
+            <param name="asyncResult">The result of the asynchronous operation</param>
+            <remarks>
+            <para>
+            On connection adds to the list of connections 
+            if there are two many open connections you will be disconnected
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Dispose">
+            <summary>
+            Close all network connections
+            </summary>
+            <remarks>
+            <para>
+            Make sure we close all network connections
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.SocketHandler.HasConnections">
+            <summary>
+            Test if this handler has active connections
+            </summary>
+            <value>
+            <c>true</c> if this handler has active connections
+            </value>
+            <remarks>
+            <para>
+            This property will be <c>true</c> while this handler has
+            active connections, that is at least one connection that 
+            the handler will attempt to send a message to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient">
+            <summary>
+            Class that represents a client connected to this handler
+            </summary>
+            <remarks>
+            <para>
+            Class that represents a client connected to this handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.#ctor(System.Net.Sockets.Socket)">
+            <summary>
+            Create this <see cref="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient"/> for the specified <see cref="T:System.Net.Sockets.Socket"/>
+            </summary>
+            <param name="socket">the client's socket</param>
+            <remarks>
+            <para>
+            Opens a stream writer on the socket.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Send(System.String)">
+            <summary>
+            Write a string to the client
+            </summary>
+            <param name="message">string to send</param>
+            <remarks>
+            <para>
+            Write a string to the client
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Dispose">
+            <summary>
+            Cleanup the clients connection
+            </summary>
+            <remarks>
+            <para>
+            Close the socket connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TraceAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Trace"/> class for details on configuring the
+            trace system.
+            </para>
+            <para>
+            Events are written using the <c>System.Diagnostics.Trace.Write(string,string)</c>
+            method. The event's logger name is the default value for the category parameter 
+            of the Write method. 
+            </para>
+            <para>
+            <b>Compact Framework</b><br/>
+            The Compact Framework does not support the <see cref="T:System.Diagnostics.Trace"/>
+            class for any operation except <c>Assert</c>. When using the Compact Framework this
+            appender will write to the <see cref="T:System.Diagnostics.Debug"/> system rather than
+            the Trace system. This appender will therefore behave like the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </para>
+            </remarks>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.AliasDomainAttribute">
+            <summary>
+            Assembly level attribute that specifies a domain to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.DomainAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's domain to its repository by
+            specifying this attribute with the name of the target domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required domains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.AliasRepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies a repository to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.RepositoryAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's repository to its repository by
+            specifying this attribute with the name of the target repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required repositories.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.AliasRepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </summary>
+            <param name="name">The repository to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.AliasRepositoryAttribute.Name">
+            <summary>
+            Gets or sets the repository to alias to this assemby's repository.
+            </summary>
+            <value>
+            The repository to alias to this assemby's repository.
+            </value>
+            <remarks>
+            <para>
+            The name of the repository to alias to this assemby's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.AliasDomainAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasDomainAttribute"/> class with 
+            the specified domain to alias to this assembly's repository.
+            </summary>
+            <param name="name">The domain to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Obsolete. Use <see cref="T:log4net.Config.AliasRepositoryAttribute"/> instead of <see cref="T:log4net.Config.AliasDomainAttribute"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.BasicConfigurator">
+            <summary>
+            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </summary>
+            <remarks>
+            <para>
+            Allows very simple programmatic configuration of log4net.
+            </para>
+            <para>
+            Only one appender can be configured using this configurator.
+            The appender is set at the root of the hierarchy and all logging
+            events will be delivered to that appender.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Config.BasicConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the BasicConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.BasicConfigurator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure">
+            <summary>
+            Initializes the log4net system with a default configuration.
+            </summary>
+            <remarks>
+            <para>
+            Initializes the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the log4net system using the specified appenders.
+            </summary>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initializes the log4net system using the specified appender.
+            </summary>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> with a default configuration.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Initializes the specified repository using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appenders.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.ConfiguratorAttribute">
+            <summary>
+            Base class for all log4net configuration attributes.
+            </summary>
+            <remarks>
+            This is an abstract class that must be extended by 
+            specific configurators. This attribute allows the
+            configurator to be parameterized by an assembly level
+            attribute.
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">
+            <summary>
+            Constructor used by subclasses.
+            </summary>
+            <param name="priority">the ordering priority for this configurator</param>
+            <remarks>
+            <para>
+            The <paramref name="priority"/> is used to order the configurator
+            attributes before they are invoked. Higher priority configurators are executed
+            before lower priority ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Abstract method implemented by a subclass. When this method is called
+            the subclass should configure the <paramref name="targetRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">
+            <summary>
+            Compare this instance to another ConfiguratorAttribute
+            </summary>
+            <param name="obj">the object to compare to</param>
+            <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>
+            <remarks>
+            <para>
+            Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.
+            Sorts by priority in descending order. Objects with the same priority are
+            randomly ordered.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DomainAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging domain for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            <b>DomainAttribute is obsolete. Use RepositoryAttribute instead of DomainAttribute.</b>
+            </para>
+            <para>
+            Assemblies are mapped to logging domains. Each domain has its own
+            logging repository. This attribute specified on the assembly controls
+            the configuration of the domain. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the repository objects to create for the domain. If 
+            this attribute is not specified and a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> is not specified
+            then the assembly will be part of the default shared logging domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.RepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging repository for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            Assemblies are mapped to logging repository. This attribute specified 
+            on the assembly controls
+            the configuration of the repository. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the repository that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the <see cref="T:log4net.Repository.ILoggerRepository"/> object 
+            to create for the assembly. If this attribute is not specified or a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> 
+            is not specified then the assembly will be part of the default shared logging repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class 
+            with the name of the repository.
+            </summary>
+            <param name="name">The name of the repository.</param>
+            <remarks>
+            <para>
+            Initialize the attribute with the name for the assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.Name">
+            <summary>
+            Gets or sets the name of the logging repository.
+            </summary>
+            <value>
+            The string name to use as the name of the repository associated with this
+            assembly.
+            </value>
+            <remarks>
+            <para>
+            This value does not have to be unique. Several assemblies can share the
+            same repository. They will share the logging configuration of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.RepositoryType">
+            <summary>
+            Gets or sets the type of repository to create for this assembly.
+            </summary>
+            <value>
+            The type of repository to create for this assembly.
+            </value>
+            <remarks>
+            <para>
+            The type of the repository to create for the assembly.
+            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            interface.
+            </para>
+            <para>
+            This will be the type of repository created when 
+            the repository is created. If multiple assemblies reference the
+            same repository then the repository is only created once using the
+            <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/> of the first assembly to call into the 
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class 
+            with the name of the domain.
+            </summary>
+            <param name="name">The name of the domain.</param>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DOMConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="T:log4net.Config.DOMConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.XmlConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            <para>
+            If neither of the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>
+            properties are set the configuration is loaded from the application's .config file.
+            If set the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property takes priority over the
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property. The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property
+            specifies a path to a file to load the config from. The path is relative to the
+            application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property is used as a postfix to the assembly file name.
+            The config file must be located in the  application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            For example in a console application setting the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> to
+            <c>config</c> has the same effect as not specifying the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or 
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> properties.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.Watch"/> property can be set to cause the <see cref="T:log4net.Config.XmlConfigurator"/>
+            to watch the configuration file for changes.
+            </para>
+            <note>
+            <para>
+            Log4net will only look for assembly level configuration attributes once.
+            When using the log4net assembly level attributes to control the configuration 
+            of log4net you must ensure that the first call to any of the 
+            <see cref="T:log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration
+            attributes. 
+            </para>
+            <para>
+            If you cannot guarantee the order in which log4net calls will be made from 
+            different assemblies you must use programmatic configuration instead, i.e.
+            call the <see cref="M:XmlConfigurator.Configure()"/> method directly.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Configure the repository using the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            The <paramref name="targetRepository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>
+            class otherwise the <see cref="T:log4net.Config.XmlConfigurator"/> will not be able to
+            configure it.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="targetRepository"/> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.</exception>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from the local file system
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configure the specified repository using a <see cref="T:System.IO.FileInfo"/>
+            </summary>
+            <param name="targetRepository">The repository to configure.</param>
+            <param name="configFile">the FileInfo pointing to the config file</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromUri(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from a URI
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="F:log4net.Config.XmlConfiguratorAttribute.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfiguratorAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile">
+            <summary>
+            Gets or sets the filename of the configuration file.
+            </summary>
+            <value>
+            The filename of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified, this is the name of the configuration file to use with
+            the <see cref="T:log4net.Config.XmlConfigurator"/>. This file path is relative to the
+            <b>application base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>).
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension">
+            <summary>
+            Gets or sets the extension of the configuration file.
+            </summary>
+            <value>
+            The extension of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified this is the extension for the configuration file.
+            The path to the config file is built by using the <b>application 
+            base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>),
+            the <b>assembly file name</b> and the config file extension.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> is set to <c>MyExt</c> then
+            possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or
+            <c>MyClassLibrary.dll.MyExt</c>.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.Watch">
+            <summary>
+            Gets or sets a value indicating whether to watch the configuration file.
+            </summary>
+            <value>
+            <c>true</c> if the configuration should be watched, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            If this flag is specified and set to <c>true</c> then the framework
+            will watch the configuration file and will reload the config each time 
+            the file is modified.
+            </para>
+            <para>
+            The config file can only be watched if it is loaded from local disk.
+            In a No-Touch (Smart Client) deployment where the application is downloaded
+            from a web server the config file may not reside on the local disk
+            and therefore it may not be able to watch it.
+            </para>
+            <note>
+            Watching configuration is not supported on the SSCLI.
+            </note>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
+            <summary>
+            Class to register for the log4net section of the configuration file
+            </summary>
+            <remarks>
+            The log4net section of the configuration file needs to have a section
+            handler registered. This is the section handler used. It simply returns
+            the XML element that is the root of the section.
+            </remarks>
+            <example>
+            Example of registering the log4net section handler :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<configSections>
+            		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
+            	</configSections>
+            	<log4net>
+            		log4net configuration XML goes here
+            	</log4net>
+            </configuration>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
+            <summary>
+            Parses the configuration section.
+            </summary>
+            <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
+            <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>
+            <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>
+            <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.PluginAttribute">
+            <summary>
+            Assembly level attribute that specifies a plugin to attach to 
+            the repository.
+            </summary>
+            <remarks>
+            <para>
+            Specifies the type of a plugin to create and attach to the
+            assembly's repository. The plugin type must implement the
+            <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Plugin.IPluginFactory">
+            <summary>
+            Interface used to create plugins.
+            </summary>
+            <remarks>
+            <para>
+            Interface used to create  a plugin.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPluginFactory.CreatePlugin">
+            <summary>
+            Creates the plugin object.
+            </summary>
+            <returns>the new plugin instance</returns>
+            <remarks>
+            <para>
+            Create and return a new plugin instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="typeName">The type name of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            <para>
+            Where possible use the constructor that takes a <see cref="T:System.Type"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.Type)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="type">The type of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.CreatePlugin">
+            <summary>
+            Creates the plugin object defined by this attribute.
+            </summary>
+            <remarks>
+            <para>
+            Creates the instance of the <see cref="T:log4net.Plugin.IPlugin"/> object as 
+            specified by this attribute.
+            </para>
+            </remarks>
+            <returns>The plugin object.</returns>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.ToString">
+            <summary>
+            Returns a representation of the properties of this object.
+            </summary>
+            <remarks>
+            <para>
+            Overrides base class <see cref="M:Object.ToString()" /> method to 
+            return a representation of the properties of this object.
+            </para>
+            </remarks>
+            <returns>A representation of the properties of this object</returns>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.Type">
+            <summary>
+            Gets or sets the type for the plugin.
+            </summary>
+            <value>
+            The type for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type for the plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.TypeName">
+            <summary>
+            Gets or sets the type name for the plugin.
+            </summary>
+            <value>
+            The type name for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type name for the plugin.
+            </para>
+            <para>
+            Where possible use the <see cref="P:log4net.Config.PluginAttribute.Type"/> property instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.SecurityContextProviderAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">
+            <summary>
+            Construct provider attribute with type specified
+            </summary>
+            <param name="providerType">the type of the provider to use</param>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the SecurityContextProvider
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.
+            Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.SecurityContextProviderAttribute.declaringType">
+            <summary>
+            The fully qualified type of the SecurityContextProviderAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">
+            <summary>
+            Gets or sets the type of the provider to use.
+            </summary>
+            <value>
+            the type of the provider to use.
+            </value>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Uri)">
+            <summary>
+            Configures log4net using the specified configuration URI.
+            </summary>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration data stream.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Uri)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            URI.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.InternalConfigureFromXml(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the specified repository using a <c>log4net</c> element.
+            </summary>
+            <param name="repository">The hierarchy to configure.</param>
+            <param name="element">The element to parse.</param>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            <para>
+            This method is ultimately called by one of the Configure methods 
+            to load the configuration from an <see cref="T:System.Xml.XmlElement"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.m_repositoryName2ConfigAndWatchHandler">
+            <summary>
+            Maps repository names to ConfigAndWatchHandler instances to allow a particular
+            ConfigAndWatchHandler to dispose of its FileSystemWatcher when a repository is 
+            reconfigured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler">
+            <summary>
+            Class used to watch config files.
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="T:System.IO.FileSystemWatcher"/> to monitor
+            changes to a specified file. Because multiple change notifications
+            may be raised when the file is modified, a timer is used to
+            compress the notifications into a single event. The timer
+            waits for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> time before delivering
+            the event notification. If any further <see cref="T:System.IO.FileSystemWatcher"/>
+            change notifications arrive while the timer is waiting it
+            is reset and waits again for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> to
+            elapse.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis">
+            <summary>
+            The default amount of time to wait after receiving notification
+            before reloading the config file.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_configFile">
+            <summary>
+            Holds the FileInfo used to configure the XmlConfigurator
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_repository">
+            <summary>
+            Holds the repository being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_timer">
+            <summary>
+            The timer used to compress the notification events.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_watcher">
+            <summary>
+            Watches file for changes. This object should be disposed when no longer
+            needed to free system handles on the watched resources.
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class to
+            watch a specified config file used to configure a repository.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The configuration file to watch.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.OnWatchedFileChange(System.Object)">
+            <summary>
+            Called by the timer when the configuration has been updated.
+            </summary>
+            <param name="state">null</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.Dispose">
+            <summary>
+            Release the handles held by the watcher and timer.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.CompactRepositorySelector">
+            <summary>
+            The implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface suitable
+            for use with the compact framework
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.IRepositorySelector"/> implementation is a simple
+            mapping between repository name and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            object.
+            </para>
+            <para>
+            The .NET Compact Framework 1.0 does not support retrieving assembly
+            level attributes therefore unlike the <c>DefaultRepositorySelector</c>
+            this selector does not examine the calling assembly for attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Core.IRepositorySelector">
+            <summary>
+            Interface used by the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.Core.IRepositorySelector"/> 
+            to specify the policy for selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> 
+            to return to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association. The results of this method must be repeatable, i.e.
+            when called again with the same arguments the result must be the
+            save value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the named <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repositoryName">The name to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            Lookup a named <see cref="T:log4net.Repository.ILoggerRepository"/>. This is the repository created by
+            calling <see cref="M:CreateRepository(string,Type)"/>.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="assembly">The assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository with the name specified.
+            </summary>
+            <param name="repositoryName">The name to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the name
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same name will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(Assembly, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(Assembly)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>
+            An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances created by 
+            this <see cref="T:log4net.Core.IRepositorySelector"/>.</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Create a new repository selector
+            </summary>
+            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new compact repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
+            </summary>
+            <param name="assembly">not used</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <param name="repositoryName">the name of the repository to lookup</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>. The default 
+            repository is <c>log4net-default-repository</c>. Other repositories 
+            must be created using the <see cref="M:CreateRepository(string, Type)"/>.
+            If the named repository does not exist an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> does not exist</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="assembly">not used</param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            If the <paramref name="repositoryType"/> is <c>null</c> then the
+            default repository type specified to the constructor is used.
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Create a new repository for the repository specified
+            </summary>
+            <param name="repositoryName">the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is null then the default repository type is used.</param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            <para>
+            If the named repository already exists an exception will be thrown.
+            </para>
+            <para>
+            If <paramref name="repositoryType"/> is <c>null</c> then the default 
+            repository type specified to the constructor is used.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> already exists</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.CompactRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the CompactRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notify the registered listeners that the repository has been created
+            </summary>
+            <param name="repository">The repository that has been created</param>
+            <remarks>
+            <para>
+            Raises the <event cref="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">LoggerRepositoryCreatedEvent</event>
+            event.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.DefaultRepositorySelector">
+            <summary>
+            The default implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Uses attributes defined on the calling assembly to determine how to
+            configure the hierarchy for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Creates a new repository selector.
+            </summary>
+            <param name="defaultRepositoryType">The type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null"/>.</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="repositoryAssembly">The assembly use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <remarks>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and the repository 
+            to create can be overridden by specifying the <see cref="T:log4net.Config.RepositoryAttribute"/> 
+            attribute on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> 
+            implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically configured using 
+            any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
+            the <paramref name="repositoryAssembly"/>.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.</returns>
+            <remarks>
+            <para>
+            Returns the named repository. If <paramref name="repositoryName"/> is <c>null</c>
+            a <see cref="T:System.ArgumentNullException"/> is thrown. If the repository 
+            does not exist a <see cref="T:log4net.Core.LogException"/> is thrown.
+            </para>
+            <para>
+            Use <see cref="M:CreateRepository(string, Type)"/> to create a repository.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> does not exist.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type,System.String,System.Boolean)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryName">The name to assign to the created repository</param>
+            <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is <see langword="null"/> then the default repository type is used.</param>
+            <returns>The new repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.AliasRepository(System.String,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Aliases a repository to an existing repository.
+            </summary>
+            <param name="repositoryAlias">The repository to alias.</param>
+            <param name="repositoryTarget">The repository that the repository is aliased to.</param>
+            <remarks>
+            <para>
+            The repository specified will be aliased to the repository when created. 
+            The repository must not already exist.
+            </para>
+            <para>
+            When the repository is created it must utilize the same repository type as 
+            the repository it is aliased to, otherwise the aliasing will fail.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="repositoryAlias"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repositoryTarget"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notifies the registered listeners that the repository has been created.
+            </summary>
+            <param name="repository">The repository that has been created.</param>
+            <remarks>
+            <para>
+            Raises the <see cref="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">
+            <summary>
+            Gets the repository name and repository type for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly that has a <see cref="T:log4net.Config.RepositoryAttribute"/>.</param>
+            <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>
+            <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>
+            <exception cref="T:System.ArgumentNullException"><paramref name="assembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the repository using information from the assembly.
+            </summary>
+            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>
+            attributes which define the configuration for the repository.</param>
+            <param name="repository">The repository to configure.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadPlugins(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined plugins on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to add the plugins to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadAliases(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined aliases on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to alias to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="F:log4net.Core.DefaultRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the DefaultRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ErrorCode">
+            <summary>
+            Defined error codes that can be passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Values passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.GenericFailure">
+            <summary>
+            A general error
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.WriteFailure">
+            <summary>
+            Error while writing output
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FlushFailure">
+            <summary>
+            Failed to flush file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.CloseFailure">
+            <summary>
+            Failed to close file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FileOpenFailure">
+            <summary>
+            Unable to open output file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.MissingLayout">
+            <summary>
+            No layout specified
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.AddressParseFailure">
+            <summary>
+            Failed to parse address
+            </summary>
+        </member>
+        <member name="T:log4net.Core.ExceptionEvaluator">
+            <summary>
+            An evaluator that triggers on an Exception type
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the type of the Exception
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to a Type in <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.    /// 
+            </para>
+            </remarks>
+            <author>Drew Schaeffer</author>
+        </member>
+        <member name="T:log4net.Core.ITriggeringEventEvaluator">
+            <summary>
+            Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action
+            </summary>
+            <remarks>
+            <para>
+            Implementations of this interface allow certain appenders to decide
+            when to perform an appender specific action.
+            </para>
+            <para>
+            The action or behavior triggered is defined by the implementation.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if this event triggers the action
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
+            <remarks>
+            <para>
+            Return <c>true</c> if this event triggers the action
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_type">
+            <summary>
+            The type that causes the trigger to fire.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_triggerOnSubclass">
+            <summary>
+            Causes subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/> to cause the trigger to fire.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor">
+            <summary>
+            Default ctor to allow dynamic creation through a configurator.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor(System.Type,System.Boolean)">
+            <summary>
+            Constructs an evaluator and initializes to trigger on <paramref name="exType"/>
+            </summary>
+            <param name="exType">the type that triggers this evaluator.</param>
+            <param name="triggerOnSubClass">If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.</param>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the logging event Exception 
+            Type is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the Exception Type of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.ExceptionType">
+            <summary>
+            The type that triggers this evaluator.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.TriggerOnSubclass">
+            <summary>
+            If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.IErrorHandler">
+            <summary>
+            Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.
+            </summary>
+            <remarks>
+            <para>
+            Error handling is a particularly tedious to get right because by
+            definition errors are hard to predict and to reproduce. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <param name="errorCode">The error code associated with the error.</param>
+            <remarks>
+            <para>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IFixingRequired">
+            <summary>
+            Interface for objects that require fixing.
+            </summary>
+            <remarks>
+            <para>
+            Interface that indicates that the object requires fixing before it
+            can be taken outside the context of the appender's 
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            When objects that implement this interface are stored 
+            in the context properties maps <see cref="T:log4net.GlobalContext"/>
+            <see cref="P:log4net.GlobalContext.Properties"/> and <see cref="T:log4net.ThreadContext"/>
+            <see cref="P:log4net.ThreadContext.Properties"/> are fixed 
+            (see <see cref="P:log4net.Core.LoggingEvent.Fix"/>) the <see cref="M:log4net.Core.IFixingRequired.GetFixedObject"/>
+            method will be called.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IFixingRequired.GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a portable instance object that represents the current
+            state of this object. The portable object can be stored
+            and logged from any thread with identical results.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILogger">
+            <summary>
+            Interface that all loggers implement
+            </summary>
+            <remarks>
+            <para>
+            This interface supports logging events and testing if a level
+            is enabled for logging.
+            </para>
+            <para>
+            These methods will not throw exceptions. Note to implementor, ensure
+            that the implementation of these methods cannot allow an exception
+            to be thrown to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">the exception to log, including its stack trace. Pass <c>null</c> to not log an exception.</param>
+            <remarks>
+            <para>
+            Generates a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="T:log4net.Core.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Name">
+            <summary>
+            Gets the name of the logger.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILoggerWrapper">
+            <summary>
+            Base interface for all wrappers
+            </summary>
+            <remarks>
+            <para>
+            Base interface for all wrappers.
+            </para>
+            <para>
+            All wrappers must implement this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Core.ILoggerWrapper.Logger">
+            <summary>
+            Get the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this
+            object. The <c>Logger</c> object may not 
+            be the same object as this object because of logger decorators.
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventHandler">
+            <summary>
+            Delegate used to handle logger repository creation event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Core.IRepositorySelector"/> which created the repository.</param>
+            <param name="e">The <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> event args
+            that holds the <see cref="T:log4net.Repository.ILoggerRepository"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> 
+            event is raised every time a <see cref="T:log4net.Repository.ILoggerRepository"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerRepositoryCreationEventArgs.m_repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggerRepositoryCreationEventArgs.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </summary>
+            <param name="repository">the <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created</param>
+            <remarks>
+            <para>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggerRepositoryCreationEventArgs.LoggerRepository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.Level">
+            <summary>
+            Defines the default set of levels recognized by the system.
+            </summary>
+            <remarks>
+            <para>
+            Each <see cref="T:log4net.Core.LoggingEvent"/> has an associated <see cref="T:log4net.Core.Level"/>.
+            </para>
+            <para>
+            Levels have a numeric <see cref="P:log4net.Core.Level.Value"/> that defines the relative 
+            ordering between levels. Two Levels with the same <see cref="P:log4net.Core.Level.Value"/> 
+            are deemed to be equivalent.
+            </para>
+            <para>
+            The levels that are recognized by log4net are set for each <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and each repository can have different levels defined. The levels are stored
+            in the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> on the repository. Levels are
+            looked up by name from the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>.
+            </para>
+            <para>
+            When logging at level INFO the actual level used is not <see cref="F:log4net.Core.Level.Info"/> but
+            the value of <c>LoggerRepository.LevelMap["INFO"]</c>. The default value for this is
+            <see cref="F:log4net.Core.Level.Info"/>, but this can be changed by reconfiguring the level map.
+            </para>
+            <para>
+            Each level has a <see cref="P:log4net.Core.Level.DisplayName"/> in addition to its <see cref="P:log4net.Core.Level.Name"/>. The 
+            <see cref="P:log4net.Core.Level.DisplayName"/> is the string that is written into the output log. By default
+            the display name is the same as the level name, but this can be used to alias levels
+            or to localize the log output.
+            </para>
+            <para>
+            Some of the predefined levels recognized by the system are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Off"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Fatal"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Error"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Warn"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Info"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Debug"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.All"/>.</description>
+            	</item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <param name="displayName">The display name for this level. This may be localized or otherwise different from the name</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.ToString">
+            <summary>
+            Returns the <see cref="T:System.String"/> representation of the current 
+            <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <returns>
+            A <see cref="T:System.String"/> representation of the current <see cref="T:log4net.Core.Level"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns the level <see cref="P:log4net.Core.Level.Name"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Equals(System.Object)">
+            <summary>
+            Compares levels.
+            </summary>
+            <param name="o">The object to compare against.</param>
+            <returns><c>true</c> if the objects are equal.</returns>
+            <remarks>
+            <para>
+            Compares the levels of <see cref="T:log4net.Core.Level"/> instances, and 
+            defers to base class if the target object is not a <see cref="T:log4net.Core.Level"/>
+            instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.GetHashCode">
+            <summary>
+            Returns a hash code
+            </summary>
+            <returns>A hash code for the current <see cref="T:log4net.Core.Level"/>.</returns>
+            <remarks>
+            <para>
+            Returns a hash code suitable for use in hashing algorithms and data 
+            structures like a hash table.
+            </para>
+            <para>
+            Returns the hash code of the level <see cref="P:log4net.Core.Level.Value"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.CompareTo(System.Object)">
+            <summary>
+            Compares this instance to a specified object and returns an 
+            indication of their relative values.
+            </summary>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> instance or <see langword="null"/> to compare with this instance.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description>This instance is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description>This instance is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description>
+            			<para>This instance is greater than <paramref name="r"/>.</para>
+            			<para>-or-</para>
+            			<para><paramref name="r"/> is <see langword="null"/>.</para>
+            			</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            <paramref name="r"/> must be an instance of <see cref="T:log4net.Core.Level"/> 
+            or <see langword="null"/>; otherwise, an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException"><paramref name="r"/> is not a <see cref="T:log4net.Core.Level"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Equality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have the same value.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is the same as the 
+            value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Inequality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have different values.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is different from
+            the value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Compare(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Compares two specified <see cref="T:log4net.Core.Level"/> instances.
+            </summary>
+            <param name="l">The first <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <param name="r">The second <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            two values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description><paramref name="l"/> is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description><paramref name="l"/> is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description><paramref name="l"/> is greater than <paramref name="r"/>.</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.Level.Off">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Off"/> level designates a higher level than all the rest.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Log4Net_Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Emergency">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fatal">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fatal"/> level designates very severe error events 
+            that will presumably lead the application to abort.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Alert">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Alert"/> level designates very severe error events. 
+            Take immediate action, alerts.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Critical">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Critical"/> level designates very severe error events. 
+            Critical condition, critical.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Severe">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Severe"/> level designates very severe error events.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Error">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Error"/> level designates error events that might 
+            still allow the application to continue running.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Warn">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Warn"/> level designates potentially harmful 
+            situations.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Notice">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Notice"/> level designates informational messages 
+            that highlight the progress of the application at the highest level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Info">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Info"/> level designates informational messages that 
+            highlight the progress of the application at coarse-grained level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Debug"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fine">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fine"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Trace">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Trace"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finer">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finer"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Verbose">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Verbose"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finest">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finest"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.All">
+            <summary>
+            The <see cref="F:log4net.Core.Level.All"/> level designates the lowest level possible.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.Level.Name">
+            <summary>
+            Gets the name of this level.
+            </summary>
+            <value>
+            The name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.Value">
+            <summary>
+            Gets the value of this level.
+            </summary>
+            <value>
+            The value of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the value of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.DisplayName">
+            <summary>
+            Gets the display name of this level.
+            </summary>
+            <value>
+            The display name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the display name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Core.Level"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ReadOnly(log4net.Core.LevelCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>LevelCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>LevelCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>LevelCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <c>LevelCollection</c>.
+            </summary>
+            <param name="c">The <c>LevelCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.Level[])">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Core.Level"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[])">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[],System.Int32)">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Add(log4net.Core.Level)">
+            <summary>
+            Adds a <see cref="T:log4net.Core.Level"/> to the end of the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to be added to the end of the <c>LevelCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clear">
+            <summary>
+            Removes all elements from the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Core.LevelCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Contains(log4net.Core.Level)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Core.Level"/> is in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.IndexOf(log4net.Core.Level)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Core.Level"/>
+            in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to locate in the <c>LevelCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>LevelCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Insert(System.Int32,log4net.Core.Level)">
+            <summary>
+            Inserts an element into the <c>LevelCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Remove(log4net.Core.Level)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Core.Level"/> from the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to remove from the <c>LevelCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Core.Level"/> was not found in the <c>LevelCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>LevelCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>LevelCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Core.LevelCollection.Enumerator"/> for the entire <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.LevelCollection)">
+            <summary>
+            Adds the elements of another <c>LevelCollection</c> to the current <c>LevelCollection</c>.
+            </summary>
+            <param name="x">The <c>LevelCollection</c> whose elements should be added to the end of the current <c>LevelCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.Level[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> array to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> collection to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.Level"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>LevelCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.ILevelCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LevelCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelEvaluator">
+            <summary>
+            An evaluator that triggers at a threshold level
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelEvaluator.m_threshold">
+            <summary>
+            The threshold for triggering
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor(log4net.Core.Level)">
+            <summary>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </summary>
+            <param name="threshold">the threshold to trigger at</param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the event level
+            is equal or higher than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelEvaluator.Threshold">
+            <summary>
+            the threshold to trigger at
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.Level"/> that will cause this evaluator to trigger
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelMap">
+            <summary>
+            Mapping between string name and Level object
+            </summary>
+            <remarks>
+            <para>
+            Mapping between string name and <see cref="T:log4net.Core.Level"/> object.
+            This mapping is held separately for each <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The level name is case insensitive.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelMap.m_mapName2Level">
+            <summary>
+            Mapping from level name to Level object. The
+            level name is case insensitive
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelMap.#ctor">
+            <summary>
+            Construct the level map
+            </summary>
+            <remarks>
+            <para>
+            Construct the level map.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Clear">
+            <summary>
+            Clear the internal maps of all levels
+            </summary>
+            <remarks>
+            <para>
+            Clear the internal maps of all levels
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+            <seealso cref="M:Add(string,int,string)"/>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32,System.String)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <param name="displayName">the display name to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(log4net.Core.Level)">
+            <summary>
+            Add a Level to the map
+            </summary>
+            <param name="level">the Level to add</param>
+            <remarks>
+            <para>
+            Add a Level to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.LookupWithDefault(log4net.Core.Level)">
+            <summary>
+            Lookup a named level from the map
+            </summary>
+            <param name="defaultLevel">the name of the level to lookup is taken from this level. 
+            If the level is not set on the map then this level is added</param>
+            <returns>the level in the map with the name specified</returns>
+            <remarks>
+            <para>
+            Lookup a named level from the map. The name of the level to lookup is taken
+            from the <see cref="P:log4net.Core.Level.Name"/> property of the <paramref name="defaultLevel"/>
+            argument.
+            </para>
+            <para>
+            If no level with the specified name is found then the 
+            <paramref name="defaultLevel"/> argument is added to the level map
+            and returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.Item(System.String)">
+            <summary>
+            Lookup a <see cref="T:log4net.Core.Level"/> by name
+            </summary>
+            <param name="name">The name of the Level to lookup</param>
+            <returns>a Level from the map with the name specified</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:log4net.Core.Level"/> from the
+            map with the name specified. If the no level is
+            found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.AllLevels">
+            <summary>
+            Return all possible levels as a list of Level objects.
+            </summary>
+            <returns>all possible levels as a list of Level objects</returns>
+            <remarks>
+            <para>
+            Return all possible levels as a list of Level objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LocationInfo">
+            <summary>
+            The internal representation of caller location information.
+            </summary>
+            <remarks>
+            <para>
+            This class uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.Type)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class based on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="className">The fully qualified class name.</param>
+            <param name="methodName">The method name.</param>
+            <param name="fileName">The file name.</param>
+            <param name="lineNumber">The line number of the method within the file.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class with the specified data.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.declaringType">
+            <summary>
+            The fully qualified type of the LocationInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.MethodName">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.StackFrames">
+            <summary>
+            Gets the stack frames from the stack trace of the caller making the log request
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LoggerManager">
+            <summary>
+            Static manager that controls the creation of repositories
+            </summary>
+            <remarks>
+            <para>
+            Static manager that controls the creation of repositories
+            </para>
+            <para>
+            This class is used by the wrapper managers (e.g. <see cref="T:log4net.LogManager"/>)
+            to provide access to the <see cref="T:log4net.Core.ILogger"/> objects.
+            </para>
+            <para>
+            This manager also holds the <see cref="T:log4net.Core.IRepositorySelector"/> that is used to
+            lookup and create repositories. The selector can be set either programmatically using
+            the <see cref="P:log4net.Core.LoggerManager.RepositorySelector"/> property, or by setting the <c>log4net.RepositorySelector</c>
+            AppSetting in the applications config file to the fully qualified type name of the
+            selector to use. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#ctor">
+            <summary>
+            Private constructor to prevent instances. Only static methods should be used.
+            </summary>
+            <remarks>
+            <para>
+            Private constructor to prevent instances. Only static methods should be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#cctor">
+            <summary>
+            Hook the shutdown event
+            </summary>
+            <remarks>
+            <para>
+            On the full .NET runtime, the static constructor hooks up the 
+            <c>AppDomain.ProcessExit</c> and <c>AppDomain.DomainUnload</c>> events. 
+            These are used to shutdown the log4net system as the application exits.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.RegisterAppDomainEvents">
+            <summary>
+            Register for ProcessExit and DomainUnload events on the AppDomain
+            </summary>
+            <remarks>
+            <para>
+            This needs to be in a separate method because the events make
+            a LinkDemand for the ControlAppDomain SecurityPermission. Because
+            this is a LinkDemand it is demanded at JIT time. Therefore we cannot
+            catch the exception in the method itself, we have to catch it in the
+            caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified assembly's repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified assembly's repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to lookup the repository</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repository">The repository to shutdown.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repository">The repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+            <remarks>
+            <para>
+            Gets an array of all currently defined repositories.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetVersionInfo">
+            <summary>
+            Internal method to get pertinent version info.
+            </summary>
+            <returns>A string of version info.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnDomainUnload(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnProcessExit(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.declaringType">
+            <summary>
+            The fully qualified type of the LoggerManager class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.s_repositorySelector">
+            <summary>
+            Initialize the default repository selector
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerManager.RepositorySelector">
+            <summary>
+            Gets or sets the repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </summary>
+            <value>
+            The repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </value>
+            <remarks>
+            <para>
+            The repository selector (<see cref="T:log4net.Core.IRepositorySelector"/>) is used by 
+            the <see cref="T:log4net.LogManager"/> to create and select repositories 
+            (<see cref="T:log4net.Repository.ILoggerRepository"/>).
+            </para>
+            <para>
+            The caller to <see cref="T:log4net.LogManager"/> supplies either a string name 
+            or an assembly (if not supplied the assembly is inferred using 
+            <see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            <para>
+            This context is used by the selector to lookup a specific repository.
+            </para>
+            <para>
+            For the full .NET Framework, the default repository is <c>DefaultRepositorySelector</c>;
+            for the .NET Compact Framework <c>CompactRepositorySelector</c> is the default
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerWrapperImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.ILoggerWrapper"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This class should be used as the base for all wrapper implementations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerWrapperImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Constructs a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Constructs a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerWrapperImpl.m_logger">
+            <summary>
+            The logger that this object is wrapping
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerWrapperImpl.Logger">
+            <summary>
+            Gets the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that this object is implementing.
+            </value>
+            <remarks>
+            <para>
+            The <c>Logger</c> object may not be the same object as this object 
+            because of logger decorators.
+            </para>
+            <para>
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEventData">
+            <summary>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LoggerName">
+            <summary>
+            The logger name.
+            </summary>
+            <remarks>
+            <para>
+            The logger name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Level">
+            <summary>
+            Level of logging event.
+            </summary>
+            <remarks>
+            <para>
+            Level of logging event. Level cannot be Serializable
+            because it is a flyweight.  Due to its special serialization it
+            cannot be declared final either.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Message">
+            <summary>
+            The application supplied message.
+            </summary>
+            <remarks>
+            <para>
+            The application supplied message of logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ThreadName">
+            <summary>
+            The name of thread
+            </summary>
+            <remarks>
+            <para>
+            The name of thread in which this logging event was generated
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.TimeStamp">
+            <summary>
+            Gets or sets the local time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            Prefer using the <see cref="P:log4net.Core.LoggingEventData.TimeStampUtc"/> setter, since local time can be ambiguous.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LocationInfo">
+            <summary>
+            Location information for the caller.
+            </summary>
+            <remarks>
+            <para>
+            Location information for the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.UserName">
+            <summary>
+            String representation of the user
+            </summary>
+            <remarks>
+            <para>
+            String representation of the user's windows name,
+            like DOMAIN\username
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Identity">
+            <summary>
+            String representation of the identity.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the current thread's principal identity.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ExceptionString">
+            <summary>
+            The string representation of the exception
+            </summary>
+            <remarks>
+            <para>
+            The string representation of the exception
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Domain">
+            <summary>
+            String representation of the AppDomain.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Properties">
+            <summary>
+            Additional event specific properties
+            </summary>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEventData.TimeStampUtc">
+            <summary>
+            Gets or sets the UTC time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            The TimeStamp is stored in the UTC time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.FixFlags">
+            <summary>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </summary>
+            <remarks>
+            <para>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Mdc">
+            <summary>
+            Fix the MDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Ndc">
+            <summary>
+            Fix the NDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Message">
+            <summary>
+            Fix the rendered message
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.ThreadName">
+            <summary>
+            Fix the thread name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.LocationInfo">
+            <summary>
+            Fix the callers location information
+            </summary>
+            <remarks>
+            CAUTION: Very slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.UserName">
+            <summary>
+            Fix the callers windows user name
+            </summary>
+            <remarks>
+            CAUTION: Slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Domain">
+            <summary>
+            Fix the domain friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Identity">
+            <summary>
+            Fix the callers principal name
+            </summary>
+            <remarks>
+            CAUTION: May be slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Exception">
+            <summary>
+            Fix the exception text
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Properties">
+            <summary>
+            Fix the event properties. Active properties must implement <see cref="T:log4net.Core.IFixingRequired"/> in order to be eligible for fixing.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.None">
+            <summary>
+            No fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.All">
+            <summary>
+            All fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Partial">
+            <summary>
+            Partial fields fixed
+            </summary>
+            <remarks>
+            <para>
+            This set of partial fields gives good performance. The following fields are fixed:
+            </para>
+            <list type="bullet">
+            <item><description><see cref="F:log4net.Core.FixFlags.Message"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.ThreadName"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Exception"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Domain"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Properties"/></description></item>
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEvent">
+            <summary>
+            The internal representation of logging events. 
+            </summary>
+            <remarks>
+            <para>
+            When an affirmative decision is made to log then a 
+            <see cref="T:log4net.Core.LoggingEvent"/> instance is created. This instance 
+            is passed around to the different log4net components.
+            </para>
+            <para>
+            This class is of concern to those wishing to extend log4net.
+            </para>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.HostNameProperty">
+            <summary>
+            The key into the Properties map for the host name value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.IdentityProperty">
+            <summary>
+            The key into the Properties map for the thread identity value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.UserNameProperty">
+            <summary>
+            The key into the Properties map for the user name value.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,System.String,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class
+            from the supplied parameters.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="loggerName">The name of the logger of this event.</param>
+            <param name="level">The level of this event.</param>
+            <param name="message">The message of this event.</param>
+            <param name="exception">The exception for this event.</param>
+            <remarks>
+            <para>
+            Except <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.Core.LoggingEvent.Level"/> and <see cref="P:log4net.Core.LoggingEvent.LoggerName"/>, 
+            all fields of <c>LoggingEvent</c> are filled when actually needed. Call
+            <see cref="M:FixVolatileData()"/> to cache all data locally
+            to prevent inconsistencies.
+            </para>
+            <para>This method is called by the log4net framework
+            to create a logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData,log4net.Core.FixFlags)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            The <paramref name="fixedData"/> parameter should be used to specify which fields in the
+            <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>
+            will be captured from the environment if requested or fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.EnsureRepository(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Ensure that the repository is set.
+            </summary>
+            <param name="repository">the value for the repository</param>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)">
+            <summary>
+            Write the rendered message to a TextWriter
+            </summary>
+            <param name="writer">the writer to write the message to</param>
+            <remarks>
+            <para>
+            Unlike the <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property this method
+            does store the message data in the internal cache. Therefore 
+            if called only once this method should be faster than the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property, however if the message is
+            to be accessed multiple times then the property will be more efficient.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            The data in this event must be fixed before it can be serialized.
+            </para>
+            <para>
+            The <see cref="M:FixVolatileData()"/> method must be called during the
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method call if this event 
+            is to be used outside that method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            <para>
+            Does a <see cref="F:log4net.Core.FixFlags.Partial"/> fix of the data
+            in the logging event before returning the event data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData(log4net.Core.FixFlags)">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionStrRep">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            <b>Obsolete. Use <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> instead.</b>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionString">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData">
+            <summary>
+            Fix instance fields that hold volatile data.
+            </summary>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            Calling <see cref="M:FixVolatileData()"/> is equivalent to
+            calling <see cref="M:FixVolatileData(bool)"/> passing the parameter
+            <c>false</c>.
+            </para>
+            <para>
+            See <see cref="M:FixVolatileData(bool)"/> for more
+            information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)">
+            <summary>
+            Fixes instance fields that hold volatile data.
+            </summary>
+            <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            The <paramref name="fastButLoose"/> param controls the data that
+            is fixed. Some of the data that can be fixed takes a long time to 
+            generate, therefore if you do not require those settings to be fixed
+            they can be ignored by setting the <paramref name="fastButLoose"/> param
+            to <c>true</c>. This setting will ignore the <see cref="P:log4net.Core.LoggingEvent.LocationInformation"/>
+            and <see cref="P:log4net.Core.LoggingEvent.UserName"/> settings.
+            </para>
+            <para>
+            Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all 
+            settings are fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)">
+            <summary>
+            Fix the fields specified by the <see cref="T:log4net.Core.FixFlags"/> parameter
+            </summary>
+            <param name="flags">the fields to fix</param>
+            <remarks>
+            <para>
+            Only fields specified in the <paramref name="flags"/> will be fixed.
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.LookupProperty(System.String)">
+            <summary>
+            Lookup a composite property in this event
+            </summary>
+            <param name="key">the key for the property to lookup</param>
+            <returns>the value for the property</returns>
+            <remarks>
+            <para>
+            This event has composite properties that combine together properties from
+            several different contexts in the following order:
+            <list type="definition">
+            	<item>
+            		<term>this events properties</term>
+            		<description>
+            		This event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            		properties are specific to this event only.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the thread properties</term>
+            		<description>
+            		The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            		thread. These properties are shared by all events logged on this thread.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the global properties</term>
+            		<description>
+            		The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            		properties are shared by all the threads in the AppDomain.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetProperties">
+            <summary>
+            Get all the composite properties in this event
+            </summary>
+            <returns>the <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the properties</returns>
+            <remarks>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/> for details of the composite properties 
+            stored by the event.
+            </para>
+            <para>
+            This method returns a single <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the
+            properties defined for this event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_data">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_compositeProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_eventProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_callerStackBoundaryDeclaringType">
+            <summary>
+            The fully qualified Type of the calling 
+            logger class in the stack frame (i.e. the declaring type of the method).
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_message">
+            <summary>
+            The application supplied message of logging event.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_thrownException">
+            <summary>
+            The exception that was thrown.
+            </summary>
+            <remarks>
+            This is not serialized. The string representation
+            is serialized instead.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_repository">
+            <summary>
+            The repository that generated the logging event
+            </summary>
+            <remarks>
+            This is not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_fixFlags">
+            <summary>
+            The fix state for this event
+            </summary>
+            <remarks>
+            These flags indicate which fields have been fixed.
+            Not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_cacheUpdatable">
+            <summary>
+            Indicated that the internal cache is updateable (ie not fixed)
+            </summary>
+            <remarks>
+            This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler
+            changes in the caching strategy.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTime">
+            <summary>
+            Gets the time when the current process started.
+            </summary>
+            <value>
+            This is the time when this process started.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored internally in UTC and converted to the local time zone for this computer.
+            </para>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTimeUtc">
+            <summary>
+            Gets the UTC time when the current process started.
+            </summary>
+            <value>
+            This is the UTC time when this process started.
+            </value>
+            <remarks>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Level">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStamp">
+            <summary>
+            Gets the time of the logging event.
+            </summary>
+            <value>
+            The time of the logging event.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored in UTC and converted to the local time zone for this computer.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStampUtc">
+            <summary>
+            Gets UTC the time of the logging event.
+            </summary>
+            <value>
+            The UTC time of the logging event.
+            </value>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LoggerName">
+            <summary>
+            Gets the name of the logger that logged the event.
+            </summary>
+            <value>
+            The name of the logger that logged the event.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of the logger that logged the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LocationInformation">
+            <summary>
+            Gets the location information for this logging event.
+            </summary>
+            <value>
+            The location information for this logging event.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Core.LocationInfo"/> class for more information on
+            supported frameworks and the different behavior in Debug and
+            Release builds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.MessageObject">
+            <summary>
+            Gets the message object used to initialize this event.
+            </summary>
+            <value>
+            The message object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the message object used to initialize this event.
+            Note that this event may not have a valid message object.
+            If the event is serialized the message object will not 
+            be transferred. To get the text of the message the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined message object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ExceptionObject">
+            <summary>
+            Gets the exception object used to initialize this event.
+            </summary>
+            <value>
+            The exception object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the exception object used to initialize this event.
+            Note that this event may not have a valid exception object.
+            If the event is serialized the exception object will not 
+            be transferred. To get the text of the exception the
+            <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> method must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined exception object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.RenderedMessage">
+            <summary>
+            Gets the message, rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <value>
+            The message rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ThreadName">
+            <summary>
+            Gets the name of the current thread.  
+            </summary>
+            <value>
+            The name of the current thread, or the thread ID when 
+            the name is not available.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.UserName">
+            <summary>
+            Gets the name of the current user.
+            </summary>
+            <value>
+            The name of the current user, or <c>NOT AVAILABLE</c> when the 
+            underlying runtime has no support for retrieving the name of the 
+            current user.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of
+            the current windows user.
+            </para>
+            <para>
+            To improve performance, we could cache the string representation of 
+            the name, and reuse that as long as the identity stayed constant.  
+            Once the identity changed, we would need to re-assign and re-render 
+            the string.
+            </para>
+            <para>
+            However, the <c>WindowsIdentity.GetCurrent()</c> call seems to 
+            return different objects every time, so the current implementation 
+            doesn't do this type of caching.
+            </para>
+            <para>
+            Timing for these operations:
+            </para>
+            <list type="table">
+              <listheader>
+                <term>Method</term>
+                <description>Results</description>
+              </listheader>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent()</c></term>
+                <description>10000 loops, 00:00:00.2031250 seconds</description>
+              </item>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent().Name</c></term>
+                <description>10000 loops, 00:00:08.0468750 seconds</description>
+              </item>
+            </list>
+            <para>
+            This means we could speed things up almost 40 times by caching the 
+            value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since 
+            this takes (8.04-0.20) = 7.84375 seconds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Identity">
+            <summary>
+            Gets the identity of the current thread principal.
+            </summary>
+            <value>
+            The string name of the identity of the current thread principal.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get
+            the name of the current thread principal.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Domain">
+            <summary>
+            Gets the AppDomain friendly name.
+            </summary>
+            <value>
+            The AppDomain friendly name.
+            </value>
+            <remarks>
+            <para>
+            Gets the AppDomain friendly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Properties">
+            <summary>
+            Additional event specific properties.
+            </summary>
+            <value>
+            Additional event specific properties.
+            </value>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            <para>
+            This property is for events that have been added directly to
+            this event. The aggregate properties (which include these
+            event properties) can be retrieved using <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/>
+            and <see cref="M:log4net.Core.LoggingEvent.GetProperties"/>.
+            </para>
+            <para>
+            Once the properties have been fixed <see cref="P:log4net.Core.LoggingEvent.Fix"/> this property
+            returns the combined cached properties. This ensures that updates to
+            this property are always reflected in the underlying storage. When
+            returning the combined properties there may be more keys in the
+            Dictionary than expected.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Fix">
+            <summary>
+            The fixed fields in this event
+            </summary>
+            <value>
+            The set of fields that are fixed in this event
+            </value>
+            <remarks>
+            <para>
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LogImpl">
+            <summary>
+            Implementation of <see cref="T:log4net.ILog"/> wrapper interface.
+            </summary>
+            <remarks>
+            <para>
+            This implementation of the <see cref="T:log4net.ILog"/> interface
+            forwards to the <see cref="T:log4net.Core.ILogger"/> held by the base class.
+            </para>
+            <para>
+            This logger has methods to allow the caller to log at the following
+            levels:
+            </para>
+            <list type="definition">
+              <item>
+                <term>DEBUG</term>
+                <description>
+                The <see cref="M:Debug(object)"/> and <see cref="M:DebugFormat(string, object[])"/> methods log messages
+                at the <c>DEBUG</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Debug"/>. The <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>INFO</term>
+                <description>
+                The <see cref="M:Info(object)"/> and <see cref="M:InfoFormat(string, object[])"/> methods log messages
+                at the <c>INFO</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Info"/>. The <see cref="P:log4net.Core.LogImpl.IsInfoEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>WARN</term>
+                <description>
+                The <see cref="M:Warn(object)"/> and <see cref="M:WarnFormat(string, object[])"/> methods log messages
+                at the <c>WARN</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Warn"/>. The <see cref="P:log4net.Core.LogImpl.IsWarnEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>ERROR</term>
+                <description>
+                The <see cref="M:Error(object)"/> and <see cref="M:ErrorFormat(string, object[])"/> methods log messages
+                at the <c>ERROR</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Error"/>. The <see cref="P:log4net.Core.LogImpl.IsErrorEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>FATAL</term>
+                <description>
+                The <see cref="M:Fatal(object)"/> and <see cref="M:FatalFormat(string, object[])"/> methods log messages
+                at the <c>FATAL</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Fatal"/>. The <see cref="P:log4net.Core.LogImpl.IsFatalEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+            </list>
+            <para>
+            The values for these levels and their semantic meanings can be changed by 
+            configuring the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ILog">
+            <summary>
+            The ILog interface is use by application to log messages into
+            the log4net framework.
+            </summary>
+            <remarks>
+            <para>
+            Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
+            that implement this interface. The <see cref="M:LogManager.GetLogger(Assembly,Type)"/>
+            static method is used to get logger instances.
+            </para>
+            <para>
+            This class contains methods for logging at different levels and also
+            has properties for determining if those logging levels are
+            enabled in the current configuration.
+            </para>
+            <para>
+            This interface can be implemented in different ways. This documentation
+            specifies reasonable behavior that a caller can expect from the actual
+            implementation, however different implementations reserve the right to
+            do things differently.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <seealso cref="T:log4net.LogManager"/>
+            <seealso cref="M:LogManager.GetLogger(Assembly, Type)"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">
+            <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para> For some ILog interface <c>log</c>, when you write:</para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, string construction and concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed (who isn't), then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
+            the <see cref="M:Debug(object)"/>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log. This is the preferred style of logging.
+            </para>
+            <para>Alternatively if your logger is available statically then the is debug
+            enabled state can be stored in a static variable like this:
+            </para>
+            <code lang="C#">
+            private static readonly bool isDebugEnabled = log.IsDebugEnabled;
+            </code>
+            <para>
+            Then when you come to log you can write:
+            </para>
+            <code lang="C#">
+            if (isDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way the debug enabled state is only queried once
+            when the class is loaded. Using a <c>private static readonly</c>
+            variable is the most efficient because it is a run time constant
+            and can be heavily optimized by the JIT compiler.
+            </para>
+            <para>
+            Of course if you use a static readonly variable to
+            hold the enabled state of the logger then you cannot
+            change the enabled state at runtime to vary the logging
+            that is produced. You have to decide if you need absolute
+            speed or runtime flexibility.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="M:DebugFormat(IFormatProvider, string, object[])"/>
+        </member>
+        <member name="P:log4net.ILog.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="M:InfoFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="M:WarnFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="M:ErrorFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="M:FatalFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Construct a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Construct a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ReloadLevels(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Virtual method called when the configuration of the repository changes
+            </summary>
+            <param name="repository">the repository holding the levels</param>
+            <remarks>
+            <para>
+            Virtual method called when the configuration of the repository changes
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <c>DEBUG</c> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>DEBUG</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> passed
+            as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <c>INFO</c> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level.
+            </summary>
+            <param name="message">the message object to log</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <c>WARN</c> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>WARN</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <c>ERROR</c> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>ERROR</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <c>FATAL</c> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>FATAL</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.LoggerRepositoryConfigurationChanged(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for the <see cref="E:log4net.Repository.ILoggerRepository.ConfigurationChanged"/> event
+            </summary>
+            <param name="sender">the repository</param>
+            <param name="e">Empty</param>
+        </member>
+        <member name="F:log4net.Core.LogImpl.ThisDeclaringType">
+            <summary>
+            The fully qualified name of this declaring type not the type of any subclass.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>DEBUG</c>
+            level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>DEBUG</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para>
+            For some <c>log</c> Logger object, when you write:
+            </para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed, then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled())
+            { 
+             log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <c>IsDebugEnabled</c> and once in
+            the <c>Debug</c>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>INFO</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>INFO</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>WARN</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>WARN</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>ERROR</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>ERROR</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>FATAL</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>FATAL</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="T:log4net.Core.MethodItem">
+            <summary>
+            provides method information without actually referencing a System.Reflection.MethodBase
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.MethodItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor">
+            <summary>
+            constructs a method item for an unknown method.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String)">
+            <summary>
+            constructs a method item from the name of the method.
+            </summary>
+            <param name="name"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String,System.String[])">
+            <summary>
+            constructs a method item from the name of the method and its parameters.
+            </summary>
+            <param name="name"></param>
+            <param name="parameters"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.Reflection.MethodBase)">
+            <summary>
+            constructs a method item from a method base by determining the method name and its parameters.
+            </summary>
+            <param name="methodBase"></param>
+        </member>
+        <member name="F:log4net.Core.MethodItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Name">
+            <summary>
+            Gets the method name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The method name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Parameters">
+            <summary>
+            Gets the method parameters of the caller making
+            the logging request.
+            </summary>
+            <value>
+            The method parameters of the caller making
+            the logging request
+            </value>
+            <remarks>
+            <para>
+            Gets the method parameters of the caller making
+            the logging request.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContext">
+            <summary>
+            A SecurityContext used by log4net when interacting with protected resources
+            </summary>
+            <remarks>
+            <para>
+            A SecurityContext used by log4net when interacting with protected resources
+            for example with operating system services. This can be used to impersonate
+            a principal that has been granted privileges on the system resources.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.SecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns>An <see cref="T:System.IDisposable"/> instance that will
+            revoke the impersonation of this SecurityContext, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Impersonate this security context. Further calls on the current
+            thread should now be made in the security context provided
+            by this object. When the <see cref="T:System.IDisposable"/> result 
+            <see cref="M:System.IDisposable.Dispose"/> method is called the security
+            context of the thread should be reverted to the state it was in
+            before <see cref="M:log4net.Core.SecurityContext.Impersonate(System.Object)"/> was called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContextProvider">
+            <summary>
+            The <see cref="T:log4net.Core.SecurityContextProvider"/> providers default <see cref="T:log4net.Core.SecurityContext"/> instances.
+            </summary>
+            <remarks>
+            <para>
+            A configured component that interacts with potentially protected system
+            resources uses a <see cref="T:log4net.Core.SecurityContext"/> to provide the elevated
+            privileges required. If the <see cref="T:log4net.Core.SecurityContext"/> object has
+            been not been explicitly provided to the component then the component
+            will request one from this <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </para>
+            <para>
+            By default the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is
+            an instance of <see cref="T:log4net.Core.SecurityContextProvider"/> which returns only
+            <see cref="T:log4net.Util.NullSecurityContext"/> objects. This is a reasonable default
+            where the privileges required are not know by the system.
+            </para>
+            <para>
+            This default behavior can be overridden by subclassing the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            and overriding the <see cref="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)"/> method to return
+            the desired <see cref="T:log4net.Core.SecurityContext"/> objects. The default provider
+            can be replaced by programmatically setting the value of the 
+            <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> property.
+            </para>
+            <para>
+            An alternative is to use the <c>log4net.Config.SecurityContextProviderAttribute</c>
+            This attribute can be applied to an assembly in the same way as the
+            <c>log4net.Config.XmlConfiguratorAttribute"</c>. The attribute takes
+            the type to use as the <see cref="T:log4net.Core.SecurityContextProvider"/> as an argument.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.SecurityContextProvider.s_defaultProvider">
+            <summary>
+            The default provider
+            </summary>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.#ctor">
+            <summary>
+            Protected default constructor to allow subclassing
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)">
+            <summary>
+            Create a SecurityContext for a consumer
+            </summary>
+            <param name="consumer">The consumer requesting the SecurityContext</param>
+            <returns>An impersonation context</returns>
+            <remarks>
+            <para>
+            The default implementation is to return a <see cref="T:log4net.Util.NullSecurityContext"/>.
+            </para>
+            <para>
+            Subclasses should override this method to provide their own
+            behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.SecurityContextProvider.DefaultProvider">
+            <summary>
+            Gets or sets the default SecurityContextProvider
+            </summary>
+            <value>
+            The default SecurityContextProvider
+            </value>
+            <remarks>
+            <para>
+            The default provider is used by configured components that
+            require a <see cref="T:log4net.Core.SecurityContext"/> and have not had one
+            given to them.
+            </para>
+            <para>
+            By default this is an instance of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that returns <see cref="T:log4net.Util.NullSecurityContext"/> objects.
+            </para>
+            <para>
+            The default provider can be set programmatically by setting
+            the value of this property to a sub class of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that has the desired behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.StackFrameItem">
+            <summary>
+            provides stack frame information without actually referencing a System.Diagnostics.StackFrame
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.StackFrameItem.#ctor(System.Diagnostics.StackFrame)">
+            <summary>
+            returns a stack frame item from a stack frame. This 
+            </summary>
+            <param name="frame"></param>
+            <returns></returns>
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.Method">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.TimeEvaluator">
+            <summary>
+            An evaluator that triggers after specified number of seconds.
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+            <author>Robert Sevcik</author>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL">
+            <summary>
+            The default time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_interval">
+            <summary>
+            The time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_lastTimeUtc">
+            <summary>
+            The UTC time of last check. This gets updated when the object is created and when the evaluator triggers.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor(System.Int32)">
+            <summary>
+            Create a new evaluator using the specified time threshold in seconds.
+            </summary>
+            <param name="interval">
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.TimeEvaluator.Interval">
+            <summary>
+            The time threshold in seconds to trigger after
+            </summary>
+            <value>
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperCreationHandler">
+            <summary>
+            Delegate used to handle creation of new wrappers.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <remarks>
+            <para>
+            Delegate used to handle creation of new wrappers. This delegate
+            is called from the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method to construct the wrapper for the specified logger.
+            </para>
+            <para>
+            The delegate to use is supplied to the <see cref="T:log4net.Core.WrapperMap"/>
+            constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperMap">
+            <summary>
+            Maps between logger objects and wrapper objects.
+            </summary>
+            <remarks>
+            <para>
+            This class maintains a mapping between <see cref="T:log4net.Core.ILogger"/> objects and
+            <see cref="T:log4net.Core.ILoggerWrapper"/> objects. Use the <see cref="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)"/> method to 
+            lookup the <see cref="T:log4net.Core.ILoggerWrapper"/> for the specified <see cref="T:log4net.Core.ILogger"/>.
+            </para>
+            <para>
+            New wrapper instances are created by the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method. The default behavior is for this method to delegate construction
+            of the wrapper to the <see cref="T:log4net.Core.WrapperCreationHandler"/> delegate supplied
+            to the constructor. This allows specialization of the behavior without
+            requiring subclassing of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.#ctor(log4net.Core.WrapperCreationHandler)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/>
+            </summary>
+            <param name="createWrapperHandler">The handler to use to create the wrapper objects.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/> class with 
+            the specified handler to create the wrapper objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)">
+            <summary>
+            Gets the wrapper object for the specified logger.
+            </summary>
+            <returns>The wrapper object for the specified logger</returns>
+            <remarks>
+            <para>
+            If the logger is null then the corresponding wrapper is null.
+            </para>
+            <para>
+            Looks up the wrapper it it has previously been requested and
+            returns it. If the wrapper has never been requested before then
+            the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/> virtual method is
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)">
+            <summary>
+            Creates the wrapper object for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <returns>The wrapper object for the logger.</returns>
+            <remarks>
+            <para>
+            This implementation uses the <see cref="T:log4net.Core.WrapperCreationHandler"/>
+            passed to the constructor to create the wrapper. This method
+            can be overridden in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.RepositoryShutdown(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Called when a monitored repository shutdown event is received.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down</param>
+            <remarks>
+            <para>
+            This method is called when a <see cref="T:log4net.Repository.ILoggerRepository"/> that this
+            <see cref="T:log4net.Core.WrapperMap"/> is holding loggers for has signaled its shutdown
+            event <see cref="E:log4net.Repository.ILoggerRepository.ShutdownEvent"/>. The default
+            behavior of this method is to release the references to the loggers
+            and their wrappers generated for this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.ILoggerRepository_Shutdown(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for repository shutdown event.
+            </summary>
+            <param name="sender">The sender of the event.</param>
+            <param name="e">The event args.</param>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_repositories">
+            <summary>
+            Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_createWrapperHandler">
+            <summary>
+            The handler to use to create the extension wrapper objects.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_shutdownHandler">
+            <summary>
+            Internal reference to the delegate used to register for repository shutdown events.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.WrapperMap.Repositories">
+            <summary>
+            Gets the map of logger repositories.
+            </summary>
+            <value>
+            Map of logger repositories.
+            </value>
+            <remarks>
+            <para>
+            Gets the hashtable that is keyed on <see cref="T:log4net.Repository.ILoggerRepository"/>. The
+            values are hashtables keyed on <see cref="T:log4net.Core.ILogger"/> with the
+            value being the corresponding <see cref="T:log4net.Core.ILoggerWrapper"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.DateFormatter.IDateFormatter">
+            <summary>
+            Render a <see cref="T:System.DateTime"/> as a string.
+            </summary>
+            <remarks>
+            <para>
+            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
+            instance into a string.
+            </para>
+            <para>
+            The <see cref="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/> method is used to render the
+            date to a text writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the specified date as a string.
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:System.DateTime"/> as a string and write it
+            to the <see cref="T:System.IO.TextWriter"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.AbsoluteTimeDateFormat">
+            <summary>
+            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DateAndTimeDateFormat">
+            <summary>
+            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.Iso8601TimeDateFormat">
+            <summary>
+            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Renders the date into a string. Format is <c>"HH:mm:ss"</c>.
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to render the date
+            into a string using a precision up to the second. This method
+            will be called at most once per second and the result will be
+            reused if it is needed again during the same second.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Renders the date into a string. Format is "HH:mm:ss,fff".
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> method to generate the
+            time string up to the seconds and then appends the current
+            milliseconds. The results from <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> are
+            cached and <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> is called at most once
+            per second.
+            </para>
+            <para>
+            Sub classes should override <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/>
+            rather than <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeToTheSecond">
+            <summary>
+            Last stored time with precision up to the second.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeBuf">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeStrings">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"dd MMM yyyy HH:mm:ss,fff"</c>
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format 
+            <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, 
+            <c>"06 Nov 1994 15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Angelika Schnagl</author>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">
+            <summary>
+            Default constructor.
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats a DateTime in the format <c>"dd MMM yyyy HH:mm:ss"</c>
+            for example, <c>"06 Nov 1994 15:49:37"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_dateTimeFormatInfo">
+            <summary>
+            The format info for the invariant culture.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.Iso8601DateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> as <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> specified as a string: <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats the date specified as a string: <c>"yyyy-MM-dd HH:mm:ss"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.SimpleDateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="T:System.DateTime"/> <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="format">The format string.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> class 
+            with the specified format string.
+            </para>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the date using <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </summary>
+            <param name="dateToFormat">The date to convert to a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the date format string supplied to the constructor to call
+            the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method to format the date.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">
+            <summary>
+            The format string used to format the <see cref="T:System.DateTime"/>.
+            </summary>
+            <remarks>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.DenyAllFilter">
+            <summary>
+            This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>. 
+            </summary>
+            <remarks>
+            <para>
+            You can add this filter to the end of a filter chain to
+            switch from the default "accept all unless instructed otherwise"
+            filtering behavior to a "deny all unless instructed otherwise"
+            behavior.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.FilterSkeleton">
+            <summary>
+            Subclass this type to implement customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should extend this class to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.IFilter">
+            <summary>
+            Implement this interface to provide customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should implement this interface to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the logging event should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The LoggingEvent to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.IFilter.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterSkeleton.m_next">
+            <summary>
+            Points to the next filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
+            <summary>
+            Initialize the filter with the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Typically filter's options become active immediately on set, 
+            however this method must still be called. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            <para>
+            This method is marked <c>abstract</c> and must be implemented
+            in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.FilterSkeleton.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            </summary>
+            <param name="loggingEvent">the LoggingEvent to filter</param>
+            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>
+            <remarks>
+            <para>
+            Ignores the event being logged and just returns
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter
+            chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter
+            should only be used as the last filter in the chain
+            as any further filters will be ignored!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.FilterDecision">
+            <summary>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </summary>
+            <remarks>
+            <para>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Deny">
+            <summary>
+            The log event must be dropped immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Neutral">
+            <summary>
+            This filter is neutral with respect to the log event. 
+            The remaining filters, if any, should be consulted for a final decision.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Accept">
+            <summary>
+            The log event must be logged immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="T:log4net.Filter.LevelMatchFilter">
+            <summary>
+            This is a very simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and
+            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value
+            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.Core.Level"/> of the 
+            <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 
+            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set
+            to <c>true</c>, if it is <c>false</c> then 
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">
+            <summary>
+            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.Accept"/> on a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">
+            <summary>
+            the <see cref="T:log4net.Core.Level"/> to match against
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Tests if the <see cref="T:log4net.Core.Level"/> of the logging event matches that of the filter
+            </summary>
+            <param name="loggingEvent">the event to filter</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the event matches the level of the
+            filter then the result of the function depends on the
+            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then
+            the function will return <see cref="F:log4net.Filter.FilterDecision.Accept"/>, it it is false then it
+            will return <see cref="F:log4net.Filter.FilterDecision.Deny"/>. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">
+            <summary>
+            The <see cref="T:log4net.Core.Level"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            The level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LevelRangeFilter">
+            <summary>
+            This is a simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            that determine the range of priorities that are matched, and
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range
+            of priorities and the <see cref="T:log4net.Core.Level"/> of the <see cref="T:log4net.Core.LoggingEvent"/>, then the 
+            <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"/> 
+            option value is set to <c>true</c>, if it is <c>false</c>
+            then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when matching a <see cref="T:log4net.Core.Level"/>
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">
+            <summary>
+            the minimum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">
+            <summary>
+            the maximum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if the event should be logged.
+            </summary>
+            <param name="loggingEvent">the logging event to check</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the logging event is outside the range
+            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            is returned. If the <see cref="T:log4net.Core.Level"/> is matched then the value of
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">
+            <summary>
+            Set the minimum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The minimum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">
+            <summary>
+            Sets the maximum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The maximum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LoggerMatchFilter">
+            <summary>
+            Simple filter to match a string in the event's logger name.
+            </summary>
+            <remarks>
+            <para>
+            The works very similar to the <see cref="T:log4net.Filter.LevelMatchFilter"/>. It admits two 
+            options <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> and <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>. If the 
+            <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <see cref="T:log4net.Core.LoggingEvent"/> starts 
+            with the value of the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> option, then the 
+            <see cref="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in 
+            case the <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> option value is set to <c>true</c>, 
+            if it is <c>false</c> then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_loggerToMatch">
+            <summary>
+            The logger name string to substring match against the event
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>.
+            If the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> equals the beginning of 
+            the incoming <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> (<see cref="M:String.StartsWith(string)"/>)
+            then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch">
+            <summary>
+            The <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            This filter will attempt to match this value against logger name in
+            the following way. The match will be done against the beginning of the
+            logger name (using <see cref="M:String.StartsWith(string)"/>). The match is
+            case sensitive. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.MdcFilter">
+            <summary>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with layered properties the
+            <see cref="T:log4net.Filter.PropertyFilter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.PropertyFilter">
+            <summary>
+            Simple filter to match a string an event property
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the value for a
+            specific event property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Filter.StringMatchFilter">
+            <summary>
+            Simple filter to match a string in the rendered message
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the rendered message
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">
+            <summary>
+            The string to substring match against the message
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">
+            <summary>
+            A string regex to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">
+            <summary>
+            A regex object to match (generated from m_stringRegexToMatch)
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">
+            <summary>
+            Initialize and precompile the Regex if required
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the message then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">
+            <summary>
+            Sets the static string to match
+            </summary>
+            <remarks>
+            <para>
+            The string that will be substring matched against
+            the rendered message. If the message contains this
+            string then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">
+            <summary>
+            Sets the regular expression to match
+            </summary>
+            <remarks>
+            <para>
+            The regular expression pattern that will be matched against
+            the rendered message. If the message matches this
+            pattern then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.PropertyFilter.m_key">
+            <summary>
+            The key to use to lookup the string from the event properties
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The event property for the <see cref="P:log4net.Filter.PropertyFilter.Key"/> is matched against 
+            the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the property value then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.PropertyFilter.Key">
+            <summary>
+            The key to lookup in the event properties and then match against.
+            </summary>
+            <remarks>
+            <para>
+            The key name to use to lookup in the properties map of the
+            <see cref="T:log4net.Core.LoggingEvent"/>. The match will be performed against 
+            the value of this property if it exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.NdcFilter">
+            <summary>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with named stacks stored in the
+            properties collections the <see cref="T:log4net.Filter.PropertyFilter"/> should 
+            be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.NdcFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Sets the <see cref="P:log4net.Filter.PropertyFilter.Key"/> to <c>"NDC"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AppDomainPatternConverter">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Util.PatternConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            <para>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.#ctor">
+            <summary>
+            Protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternConverter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Evaluate this pattern converter and write the output to a writer.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the appropriate way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next pattern converter in the chains
+            </summary>
+            <param name="patternConverter">the pattern converter that should follow this converter in the chain</param>
+            <returns>the next converter</returns>
+            <remarks>
+            <para>
+            The PatternConverter can merge with its neighbor during this method (or a sub class).
+            Therefore the return value may or may not be the value of the argument passed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the pattern converter to the writer with appropriate formatting
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            This method calls <see cref="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)"/> to allow the subclass to perform
+            appropriate conversion of the pattern converter. If formatting options have
+            been specified via the <see cref="P:log4net.Util.PatternConverter.FormattingInfo"/> then this method will
+            apply those formattings before writing the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SpacePad(System.IO.TextWriter,System.Int32)">
+            <summary>
+            Fast space padding method.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> to which the spaces will be appended.</param>
+            <param name="length">The number of spaces to be padded.</param>
+            <remarks>
+            <para>
+            Fast space padding method.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.m_option">
+            <summary>
+            The option string to the converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionary)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionary"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionaryEnumerator)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionaryEnumerator"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteObject(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Object)">
+            <summary>
+            Write an object to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the Object to a writer. If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the object to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Next">
+            <summary>
+            Get the next pattern converter in the chain
+            </summary>
+            <value>
+            the next pattern converter in the chain
+            </value>
+            <remarks>
+            <para>
+            Get the next pattern converter in the chain
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.FormattingInfo">
+            <summary>
+            Gets or sets the formatting info for this converter
+            </summary>
+            <value>
+            The formatting info for this converter
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the formatting info for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Option">
+            <summary>
+            Gets or sets the option value for this converter
+            </summary>
+            <summary>
+            The option for this converter
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the option value for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+        </member>
+        <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">
+            <summary>
+            Flag indicating if this converter handles exceptions
+            </summary>
+            <remarks>
+            <c>false</c> if this converter handles exceptions
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">
+            <summary>
+            Flag indicating if this converter handles the logging event exception
+            </summary>
+            <value><c>false</c> if this converter handles the logging event exception</value>
+            <remarks>
+            <para>
+            If this converter handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the property should be set to <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this converter does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AppDomainPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetCachePatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetPatternLayoutConverter">
+            <summary>
+            Abstract class that provides access to the current HttpContext (<see cref="P:System.Web.HttpContext.Current"/>) that 
+            derived classes need.
+            </summary>
+            <remarks>
+            This class handles the case when HttpContext.Current is null by writing
+            <see cref="P:log4net.Util.SystemInfo.NotAvailableText"/> to the writer.
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetPatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetCachePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Cache will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetContextPatternConverter">
+            <summary>
+            Converter for items in the <see cref="T:System.Web.HttpContext"/>.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="T:System.Web.HttpContext"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetContextPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net HttpContext item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetRequestPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetRequestPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetSessionPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetSessionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Session will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.DatePatternConverter">
+            <summary>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <remarks>
+            <para>
+            Render the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,yyyy"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Layout.Pattern.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter pattern based on the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ExceptionPatternConverter">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception or the exception property specified
+            by the Option value does not exist then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            <para>
+            Recognized values for the Option parameter are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>Message</description>
+            	</item>
+            	<item>
+            		<description>Source</description>
+            	</item>
+            	<item>
+            		<description>StackTrace</description>
+            	</item>
+            	<item>
+            		<description>TargetSite</description>
+            	</item>
+            	<item>
+            		<description>HelpLink</description>
+            	</item>		
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FileLocationPatternConverter">
+            <summary>
+            Writes the caller location file name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FileLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location file name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FullLocationPatternConverter">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FullLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.IdentityPatternConverter">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.IdentityPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <paramref name="loggingEvent"/> 
+            <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LevelPatternConverter">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LineLocationPatternConverter">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LineLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LoggerPatternConverter">
+            <summary>
+            Converter for logger name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NamedPatternConverter">
+            <summary>
+            Converter to output and truncate <c>'.'</c> separated strings
+            </summary>
+            <remarks>
+            <para>
+            This abstract class supports truncating a <c>'.'</c> separated string
+            to show a specified number of elements from the right hand side.
+            This is used to truncate class names that are fully qualified.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> method to
+            return the fully qualified string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Get the fully qualified string data
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>the fully qualified name</returns>
+            <remarks>
+            <para>
+            Overridden by subclasses to get the fully qualified name before the
+            precision is applied to it.
+            </para>
+            <para>
+            Return the fully qualified <c>'.'</c> (dot/period) separated string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> to the precision
+            specified by the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.NamedPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the NamedPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LoggerPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the logger
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified logger name</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MessagePatternConverter">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MethodLocationPatternConverter">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MethodLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NdcPatternConverter">
+            <summary>
+            Converter to include event NDC
+            </summary>
+            <remarks>
+            <para>
+            Outputs the value of the event property named <c>NDC</c>.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NdcPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event NDC to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            As the thread context stacks are now stored in named event properties
+            this converter simply looks up the value of the <c>NDC</c> property.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PropertyPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">
+            <summary>
+            Converter to output the relative time of the event
+            </summary>
+            <remarks>
+            <para>
+            Converter to output the time of the event relative to the start of the program.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the relative time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the relative time of the event in milliseconds.
+            That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>
+            and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
+            <summary>
+            Helper method to get the time difference between two DateTime objects
+            </summary>
+            <param name="start">start time (in the current local time zone)</param>
+            <param name="end">end time (in the current local time zone)</param>
+            <returns>the time difference in milliseconds</returns>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTraceDetailPatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            </para>
+            </remarks>
+            <author>Adam Davies</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTracePatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            </para>
+            </remarks>
+            <author>Michael Cromwell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the strack frames to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.GetMethodInformation(log4net.Core.MethodItem)">
+            <summary>
+            Returns the Name of the method
+            </summary>
+            <param name="method"></param>
+            <remarks>This method was created, so this class could be used as a base class for StackTraceDetailPatternConverter</remarks>
+            <returns>string</returns>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTracePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTracePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTraceDetailPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTraceDetailPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ThreadPatternConverter">
+            <summary>
+            Converter to include event thread name
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ThreadPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the ThreadName to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.TypeNamePatternConverter">
+            <summary>
+            Pattern converter for the class name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.TypeNamePatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the class
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified type name for the caller location</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UserNamePatternConverter">
+            <summary>
+            Converter to include event user name
+            </summary>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UserNamePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UtcDatePatternConverter">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            Uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> 
+            in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.Pattern.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UtcDatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted
+            to Universal time before it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Layout.Pattern.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.DynamicPatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string that re-evaluates on each call.
+            </summary>
+            <remarks>
+            <para>This class is built on <see cref="T:log4net.Layout.PatternLayout"></see> and provides all the
+            features and capabilities of PatternLayout.  PatternLayout is a 'static' class
+            in that its layout is done once at configuration time.  This class will recreate
+            the layout on each reference.</para>
+            <para>One important difference between PatternLayout and DynamicPatternLayout is the
+            treatment of the Header and Footer parameters in the configuration.  The Header and Footer
+            parameters for DynamicPatternLayout must be syntactically in the form of a PatternString,
+            but should not be marked as type log4net.Util.PatternString.  Doing so causes the
+            pattern to be statically converted at configuration time and causes DynamicPatternLayout
+            to perform the same as PatternLayout.</para>
+            <para>Please see <see cref="T:log4net.Layout.PatternLayout"/> for complete documentation.</para>
+            <example>
+            &lt;layout type="log4net.Layout.DynamicPatternLayout"&gt;
+              &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;
+              &lt;param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;
+            &lt;/layout&gt;
+            </example>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.PatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string.
+            </summary>
+            <remarks>
+            <para>
+            The goal of this class is to <see cref="M:PatternLayout.Format(TextWriter,LoggingEvent)"/> a 
+            <see cref="T:log4net.Core.LoggingEvent"/> as a string. The results
+            depend on the <i>conversion pattern</i>.
+            </para>
+            <para>
+            The conversion pattern is closely related to the conversion
+            pattern of the printf function in C. A conversion pattern is
+            composed of literal text and format control expressions called
+            <i>conversion specifiers</i>.
+            </para>
+            <para>
+            <i>You are free to insert any literal text within the conversion
+            pattern.</i>
+            </para>
+            <para>
+            Each conversion specifier starts with a percent sign (%) and is
+            followed by optional <i>format modifiers</i> and a <i>conversion
+            pattern name</i>. The conversion pattern name specifies the type of
+            data, e.g. logger, level, date, thread name. The format
+            modifiers control such things as field width, padding, left and
+            right justification. The following is a simple example.
+            </para>
+            <para>
+            Let the conversion pattern be <b>"%-5level [%thread]: %message%newline"</b> and assume
+            that the log4net environment was set to use a PatternLayout. Then the
+            statements
+            </para>
+            <code lang="C#">
+            ILog log = LogManager.GetLogger(typeof(TestApp));
+            log.Debug("Message 1");
+            log.Warn("Message 2");   
+            </code>
+            <para>would yield the output</para>
+            <code>
+            DEBUG [main]: Message 1
+            WARN  [main]: Message 2  
+            </code>
+            <para>
+            Note that there is no explicit separator between text and
+            conversion specifiers. The pattern parser knows when it has reached
+            the end of a conversion specifier when it reads a conversion
+            character. In the example above the conversion specifier
+            <b>%-5level</b> means the level of the logging event should be left
+            justified to a width of five characters.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>a</term>
+                    <description>Equivalent to <b>appdomain</b></description>
+                </item>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+            			Used to output the friendly name of the AppDomain where the 
+            			logging event was generated. 
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-cache</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-context</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-request</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-session</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>c</term>
+                    <description>Equivalent to <b>logger</b></description>
+                </item>
+                <item>
+                    <term>C</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>class</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>d</term>
+                    <description>Equivalent to <b>date</b></description>
+                </item>
+                <item>
+            		<term>date</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>exception</term>
+            		<description>
+            			<para>
+            			Used to output the exception passed in with the log message.
+            			</para>
+            			<para>
+            			If an exception object is stored in the logging event
+            			it will be rendered into the pattern output with a
+            			trailing newline.
+            			If there is no exception then nothing will be output
+            			and no trailing newline will be appended.
+            			It is typical to put a newline before the exception
+            			and to have the exception as the last data in the pattern.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>F</term>
+                    <description>Equivalent to <b>file</b></description>
+                </item>
+            	<item>
+            		<term>file</term>
+            		<description>
+            			<para>
+            			Used to output the file name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>identity</term>
+            		<description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>l</term>
+                    <description>Equivalent to <b>location</b></description>
+                </item>
+                <item>
+                    <term>L</term>
+                    <description>Equivalent to <b>line</b></description>
+                </item>
+            	<item>
+            		<term>location</term>
+            		<description>
+            			<para>
+            			Used to output location information of the caller which generated
+            			the logging event.
+            			</para>
+            			<para>
+            			The location information depends on the CLI implementation but
+            			usually consists of the fully qualified name of the calling
+            			method followed by the callers source the file name and line
+            			number between parentheses.
+            			</para>
+            			<para>
+            			The location information can be very useful. However, its
+            			generation is <b>extremely</b> slow. Its use should be avoided
+            			unless execution speed is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>level</term>
+            		<description>
+            			<para>
+            			Used to output the level of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>line</term>
+            		<description>
+            			<para>
+            			Used to output the line number from where the logging request
+            			was issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>logger</term>
+                    <description>
+                        <para>
+            			Used to output the logger of the logging event. The
+            			logger conversion specifier can be optionally followed by
+            			<i>precision specifier</i>, that is a decimal constant in
+            			brackets.
+                        </para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the logger name will be
+            			printed. By default the logger name is printed in full.
+            			</para>
+            			<para>
+            			For example, for the logger name "a.b.c" the pattern
+            			<b>%logger{2}</b> will output "b.c".
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>m</term>
+                    <description>Equivalent to <b>message</b></description>
+                </item>
+                <item>
+                    <term>M</term>
+                    <description>Equivalent to <b>method</b></description>
+                </item>
+            	<item>
+            		<term>message</term>
+            		<description>
+            			<para>
+            			Used to output the application supplied message associated with 
+            			the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>mdc</term>
+            		<description>
+            			<para>
+            			The MDC (old name for the ThreadContext.Properties) is now part of the
+            			combined event properties. This pattern is supported for compatibility
+            			but is equivalent to <b>property</b>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>method</term>
+            		<description>
+            			<para>
+            			Used to output the method name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>n</term>
+                    <description>Equivalent to <b>newline</b></description>
+                </item>
+            	<item>
+            		<term>newline</term>
+            		<description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+            		</description>
+            	</item>
+            	<item>
+            		<term>ndc</term>
+            		<description>
+            			<para>
+            			Used to output the NDC (nested diagnostic context) associated
+            			with the thread that generated the logging event.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>p</term>
+                    <description>Equivalent to <b>level</b></description>
+                </item>
+                <item>
+                    <term>P</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+                <item>
+                    <term>properties</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+            	<item>
+            		<term>property</term>
+            		<description>
+            			<para>
+            			Used to output the an event specific property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are added to events by loggers or appenders. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the event properties</term>
+            					<description>
+            					The event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            					properties are specific to this event only.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+            			
+            		</description>
+            	</item>
+                <item>
+                    <term>r</term>
+                    <description>Equivalent to <b>timestamp</b></description>
+                </item>
+            	<item>
+            		<term>stacktrace</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktrace{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+            			type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>stacktracedetail</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktracedetail{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+                        type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+                <item>
+                    <term>t</term>
+                    <description>Equivalent to <b>thread</b></description>
+                </item>
+            	<item>
+            		<term>timestamp</term>
+            		<description>
+            			<para>
+            			Used to output the number of milliseconds elapsed since the start
+            			of the application until the creation of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>thread</term>
+            		<description>
+            			<para>
+            			Used to output the name of the thread that generated the
+            			logging event. Uses the thread number if no name is available.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>type</term> 
+            		<description>
+            			<para>
+            			Used to output the fully qualified type name of the caller
+            			issuing the logging request. This conversion specifier
+            			can be optionally followed by <i>precision specifier</i>, that
+            			is a decimal constant in brackets.
+            			</para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the class name will be
+            			printed. By default the class name is output in fully qualified form.
+            			</para>
+            			<para>
+            			For example, for the class name "log4net.Layout.PatternLayout", the
+            			pattern <b>%type{1}</b> will output "PatternLayout".
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating the caller class information is
+            			slow. Thus, its use should be avoided unless execution speed is
+            			not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+                </item>
+                <item>
+                    <term>u</term>
+                    <description>Equivalent to <b>identity</b></description>
+                </item>
+            	<item>
+            		<term>username</term>
+            		<description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller WindowsIdentity information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>utcdate</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>w</term>
+                    <description>Equivalent to <b>username</b></description>
+                </item>
+                <item>
+                    <term>x</term>
+                    <description>Equivalent to <b>ndc</b></description>
+                </item>
+                <item>
+                    <term>X</term>
+                    <description>Equivalent to <b>mdc</b></description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            The single letter patterns are deprecated in favor of the 
+            longer more descriptive pattern names.
+            </para>
+            <para>
+            By default the relevant information is output as is. However,
+            with the aid of format modifiers it is possible to change the
+            minimum field width, the maximum field width and justification.
+            </para>
+            <para>
+            The optional format modifier is placed between the percent sign
+            and the conversion pattern name.
+            </para>
+            <para>
+            The first optional format modifier is the <i>left justification
+            flag</i> which is just the minus (-) character. Then comes the
+            optional <i>minimum field width</i> modifier. This is a decimal
+            constant that represents the minimum number of characters to
+            output. If the data item requires fewer characters, it is padded on
+            either the left or the right until the minimum width is
+            reached. The default is to pad on the left (right justify) but you
+            can specify right padding with the left justification flag. The
+            padding character is space. If the data item is larger than the
+            minimum field width, the field is expanded to accommodate the
+            data. The value is never truncated.
+            </para>
+            <para>
+            This behavior can be changed using the <i>maximum field
+            width</i> modifier which is designated by a period followed by a
+            decimal constant. If the data item is longer than the maximum
+            field, then the extra characters are removed from the
+            <i>beginning</i> of the data item and not from the end. For
+            example, it the maximum field width is eight and the data item is
+            ten characters long, then the first two characters of the data item
+            are dropped. This behavior deviates from the printf function in C
+            where truncation is done from the end.
+            </para>
+            <para>
+            Below are various format modifier examples for the logger
+            conversion specifier.
+            </para>
+            <div class="tablediv">
+            	<table class="dtTABLE" cellspacing="0">
+            		<tr>
+            			<th>Format modifier</th>
+            			<th>left justify</th>
+            			<th>minimum width</th>
+            			<th>maximum width</th>
+            			<th>comment</th>
+            		</tr>
+            		<tr>
+            			<td align="center">%20logger</td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is less than 20
+            				characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger 
+            				name is less than 20 characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%.30logger</td>
+            			<td align="center">NA</td>
+            			<td align="center">none</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Truncate from the beginning if the logger 
+            				name is longer than 30 characters.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center"><nobr>%20.30logger</nobr></td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20.30logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            	</table>
+            </div>
+            <para>
+            <b>Note about caller location information.</b><br/>
+            The following patterns <c>%type %file %line %method %location %class %C %F %L %l %M</c> 
+            all generate caller location information.
+            Location information uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            </note>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </note>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Layout.PatternLayout"/>
+            instance using the <see cref="M:AddConverter(string, Type)"/> method.
+            </para>
+            </remarks>
+            <example>
+            This is a more detailed pattern.
+            <code><b>%timestamp [%thread] %level %logger %ndc - %message%newline</b></code>
+            </example>
+            <example>
+            A similar pattern except that the relative time is
+            right padded if less than 6 digits, thread name is right padded if
+            less than 15 characters and truncated if longer and the logger
+            name is left padded if shorter than 30 characters and truncated if
+            longer.
+            <code><b>%-6timestamp [%15.15thread] %-5level %30.30logger %ndc - %message%newline</b></code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="T:log4net.Layout.LayoutSkeleton">
+            <summary>
+            Extend this abstract class to create your own log layout format.
+            </summary>
+            <remarks>
+            <para>
+            This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
+            interface. Most layout objects should extend this class.
+            </para>
+            </remarks>
+            <remarks>
+            <note type="inheritinfo">
+            <para>
+            Subclasses must implement the <see cref="M:Format(TextWriter,LoggingEvent)"/>
+            method.
+            </para>
+            <para>
+            Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default
+            constructor.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.ILayout">
+            <summary>
+            Interface implemented by layout objects
+            </summary>
+            <remarks>
+            <para>
+            An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            as text. The <see cref="M:Format(TextWriter,LoggingEvent)"/> method is called by an
+            appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.
+            </para>
+            <para>
+            The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            text that is appender before any events and after all the events respectively.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text and output to a writer.
+            </para>
+            <para>
+            If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the
+            event to be formatted as a <see cref="T:System.String"/> then the following
+            code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.
+            </para>
+            <code lang="C#">
+            StringWriter writer = new StringWriter();
+            Layout.Format(writer, loggingEvent);
+            string formattedEvent = writer.ToString();
+            </code>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type</value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This is a MIME type e.g. <c>"text/plain"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.IgnoresException">
+            <summary>
+            Flag indicating if this layout handle exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_header">
+            <summary>
+            The header text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
+            <summary>
+            The footer text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <remarks>
+            <para>
+            <c>false</c> if this layout handles exceptions
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
+            <summary>
+            Empty default constructor
+            </summary>
+            <remarks>
+            <para>
+            Empty default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This method must be implemented by the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Convenience method for easily formatting the logging event into a string variable.
+            </summary>
+            <param name="loggingEvent"></param>
+            <remarks>
+            Creates a new StringWriter instance to store the formatted logging event.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type is <c>"text/plain"</c></value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This base class uses the value <c>"text/plain"</c>.
+            To change this value a subclass must override this
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this layout does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DefaultConversionPattern">
+            <summary>
+            Default pattern string for log output. 
+            </summary>
+            <remarks>
+            <para>
+            Default pattern string for log output. 
+            Currently set to the string <b>"%message%newline"</b> 
+            which just prints the application supplied message. 
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DetailConversionPattern">
+            <summary>
+            A detailed conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            A conversion pattern which includes Time, Thread, Logger, and Nested Context.
+            Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+            <remarks>
+            <para>
+            This static map is overridden by the m_converterRegistry instance map
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternLayout only
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+            <remarks>
+            <para>
+            Defines the builtin global rules.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor">
+            <summary>
+            Constructs a PatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            As per the <see cref="T:log4net.Core.IOptionHandler"/> contract the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>
+            method must be called after the properties on this object have been
+            configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a PatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            When using this constructor the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method 
+            need not be called. This may not be the case when using a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">
+            <summary>
+            Create the pattern parser instance
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/> that will format the event</returns>
+            <remarks>
+            <para>
+            Creates the <see cref="T:log4net.Util.PatternParser"/> used to parse the conversion string. Sets the
+            global and instance rules on the <see cref="T:log4net.Util.PatternParser"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Parse the <see cref="T:log4net.Core.LoggingEvent"/> using the patter format
+            specified in the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a named pattern converter to this instance. This
+            converter will be used in the formatting of the event.
+            This method must be called before <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>.
+            </para>
+            <para>
+            The <paramref name="type"/> specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">
+            <summary>
+            The pattern formatting string
+            </summary>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_headerPatternString">
+            <summary>
+            The header PatternString
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_footerPatternString">
+            <summary>
+            The footer PatternString
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor">
+            <summary>
+            Constructs a DynamicPatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a DynamicPatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.ExceptionLayout">
+            <summary>
+            A Layout that renders only the Exception text from the logging event
+            </summary>
+            <remarks>
+            <para>
+            A Layout that renders only the Exception text from the logging event.
+            </para>
+            <para>
+            This Layout should only be used with appenders that utilize multiple
+            layouts (e.g. <see cref="T:log4net.Appender.AdoNetAppender"/>).
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Constructs a ExceptionLayout
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            Part of the <see cref="T:log4net.Core.IOptionHandler"/> component activation
+            framework.
+            </para>
+            <para>
+            This method does nothing as options become effective immediately.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the exception text from the logging event
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Write the exception string to the <see cref="T:System.IO.TextWriter"/>.
+            The exception string is retrieved from <see cref="M:LoggingEvent.GetExceptionString()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.IRawLayout">
+            <summary>
+            Interface for raw layout objects
+            </summary>
+            <remarks>
+            <para>
+            Interface used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            to an object.
+            </para>
+            <para>
+            This interface should not be confused with the
+            <see cref="T:log4net.Layout.ILayout"/> interface. This interface is used in
+            only certain specialized situations where a raw object is
+            required rather than a formatted string. The <see cref="T:log4net.Layout.ILayout"/>
+            is not generally useful than this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.IRawLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Implement this method to create your own layout format.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Layout2RawLayoutAdapter">
+            <summary>
+            Adapts any <see cref="T:log4net.Layout.ILayout"/> to a <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <remarks>
+            <para>
+            Where an <see cref="T:log4net.Layout.IRawLayout"/> is required this adapter
+            allows a <see cref="T:log4net.Layout.ILayout"/> to be specified.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Layout.Layout2RawLayoutAdapter.m_layout">
+            <summary>
+            The layout to adapt
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Construct a new adapter
+            </summary>
+            <param name="layout">the layout to adapt</param>
+            <remarks>
+            <para>
+            Create the adapter for the specified <paramref name="layout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Format the logging event as an object.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Format the logging event as an object.
+            </para>
+            <para>
+            Uses the <see cref="T:log4net.Layout.ILayout"/> object supplied to 
+            the constructor to perform the formatting.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawLayoutConverter">
+            <summary>
+            Type converter for the <see cref="T:log4net.Layout.IRawLayout"/> interface
+            </summary>
+            <remarks>
+            <para>
+            Used to convert objects to the <see cref="T:log4net.Layout.IRawLayout"/> interface.
+            Supports converting from the <see cref="T:log4net.Layout.ILayout"/> interface to
+            the <see cref="T:log4net.Layout.IRawLayout"/> interface using the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertFrom">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from arbitrary types
+            to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to the
+            type supported by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> to the type supported
+            by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the sourceType be converted to an <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <param name="sourceType">the source to be to be converted</param>
+            <returns><c>true</c> if the source type can be converted to <see cref="T:log4net.Layout.IRawLayout"/></returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to a
+            <see cref="T:log4net.Layout.IRawLayout"/>. Only <see cref="T:log4net.Layout.ILayout"/> is supported
+            as the <paramref name="sourceType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the value to a <see cref="T:log4net.Layout.IRawLayout"/> object
+            </summary>
+            <param name="source">the value to convert</param>
+            <returns>the <see cref="T:log4net.Layout.IRawLayout"/> object</returns>
+            <remarks>
+            <para>
+            Convert the <paramref name="source"/> object to a 
+            <see cref="T:log4net.Layout.IRawLayout"/> object. If the <paramref name="source"/> object
+            is a <see cref="T:log4net.Layout.ILayout"/> then the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>
+            is used to adapt between the two interfaces, otherwise an
+            exception is thrown.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawPropertyLayout">
+            <summary>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.#ctor">
+            <summary>
+            Constructs a RawPropertyLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Lookup the property for <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns property value</returns>
+            <remarks>
+            <para>
+            Looks up and returns the object value of the property
+            named <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>. If there is no property defined
+            with than name then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.RawPropertyLayout.Key">
+            <summary>
+            The name of the value to lookup in the LoggingEvent Properties collection.
+            </summary>
+            <value>
+            Value to lookup in the LoggingEvent Properties collection
+            </value>
+            <remarks>
+            <para>
+            String name of the property to lookup in the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in local time. To format the time stamp
+            in universal time use <see cref="T:log4net.Layout.RawUtcTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawUtcTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawUtcTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in universal time. To format the time stamp
+            in local time use <see cref="T:log4net.Layout.RawTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.SimpleLayout">
+            <summary>
+            A very simple layout
+            </summary>
+            <remarks>
+            <para>
+            SimpleLayout consists of the level of the log statement,
+            followed by " - " and then the log message itself. For example,
+            <code>
+            DEBUG - Hello world
+            </code>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.#ctor">
+            <summary>
+            Constructs a SimpleLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a simple formatted output.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Formats the event as the level of the even,
+            followed by " - " and then the log message itself. The
+            output is terminated by a newline.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayout">
+             <summary>
+             Layout that formats the log events as XML elements.
+             </summary>
+             <remarks>
+             <para>
+             The output of the <see cref="T:log4net.Layout.XmlLayout"/> consists of a series of 
+             log4net:event elements. It does not output a complete well-formed XML 
+             file. The output is designed to be included as an <em>external entity</em>
+             in a separate file to form a correct XML file.
+             </para>
+             <para>
+             For example, if <c>abc</c> is the name of the file where
+             the <see cref="T:log4net.Layout.XmlLayout"/> output goes, then a well-formed XML file would 
+             be:
+             </para>
+             <code lang="XML">
+             &lt;?xml version="1.0" ?&gt;
+             
+             &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;
+            
+             &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;
+                 &amp;data;
+             &lt;/log4net:events&gt;
+             </code>
+             <para>
+             This approach enforces the independence of the <see cref="T:log4net.Layout.XmlLayout"/> 
+             and the appender where it is embedded.
+             </para>
+             <para>
+             The <c>version</c> attribute helps components to correctly
+             interpret output generated by <see cref="T:log4net.Layout.XmlLayout"/>. The value of 
+             this attribute should be "1.2" for release 1.2 and later.
+             </para>
+             <para>
+             Alternatively the <c>Header</c> and <c>Footer</c> properties can be
+             configured to output the correct XML header, open tag and close tag.
+             When setting the <c>Header</c> and <c>Footer</c> properties it is essential
+             that the underlying data store not be appendable otherwise the data
+             will become invalid XML.
+             </para>
+             </remarks>
+             <author>Nicko Cadell</author>
+             <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutBase">
+            <summary>
+            Layout that formats the log events as XML elements.
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract class that must be subclassed by an implementation 
+            to conform to a specific schema.
+            </para>
+            <para>
+            Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class
+            with no location info.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="locationInfo" /> parameter determines whether 
+            location information will be output by the layout. If 
+            <paramref name="locationInfo" /> is set to <c>true</c>, then the 
+            file name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the
+            <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed 
+            to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the
+            <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to format
+            the <see cref="T:log4net.Core.LoggingEvent"/> as XML.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">
+            <summary>
+            Flag to indicate if location information should be included in
+            the XML events.
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">
+            <summary>
+            The string to replace invalid chars with
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">
+            <summary>
+            Gets a value indicating whether to include location information in 
+            the XML events.
+            </summary>
+            <value>
+            <c>true</c> if location information should be included in the XML 
+            events; otherwise, <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file 
+            name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an <c>SMTPAppender</c>
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">
+            <summary>
+            The string to replace characters that can not be expressed in XML with.
+            <remarks>
+            <para>
+            Not all characters may be expressed in XML. This property contains the
+            string to replace those that can not with. This defaults to a ?. Set it
+            to the empty string to simply remove offending characters. For more
+            details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets
+            Character replacement will occur in  the log message, the property names 
+            and the property values.
+            </para>
+            </remarks>
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.ContentType">
+            <summary>
+            Gets the content type output by this layout. 
+            </summary>
+            <value>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </value>
+            <remarks>
+            <para>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor">
+            <summary>
+            Constructs an XmlLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XmlLayout.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SmtpAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Builds a cache of the element names
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Override the base class <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method
+            to write the <see cref="T:log4net.Core.LoggingEvent"/> to the <see cref="T:System.Xml.XmlWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayout.m_prefix">
+            <summary>
+            The prefix to use for all generated element names
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Prefix">
+            <summary>
+            The prefix to use for all element names
+            </summary>
+            <remarks>
+            <para>
+            The default prefix is <b>log4net</b>. Set this property
+            to change the prefix. If the prefix is set to an empty string
+            then no prefix will be written.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeMessage">
+            <summary>
+            Set whether or not to base64 encode the message.
+            </summary>
+            <remarks>
+            <para>
+            By default the log message will be written as text to the xml
+            output. This can cause problems when the message contains binary
+            data. By setting this to true the contents of the message will be
+            base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the log message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeProperties">
+            <summary>
+            Set whether or not to base64 encode the property values.
+            </summary>
+            <remarks>
+            <para>
+            By default the properties will be written as text to the xml
+            output. This can cause problems when one or more properties contain
+            binary data. By setting this to true the values of the properties
+            will be base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the property values.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutSchemaLog4j">
+            <summary>
+            Layout that formats the log events as XML elements compatible with the log4j schema
+            </summary>
+            <remarks>
+            <para>
+            Formats the log events according to the http://logging.apache.org/log4j schema.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutSchemaLog4j.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Actually do the writing of the xml
+            </summary>
+            <param name="writer">the writer to use</param>
+            <param name="loggingEvent">the event to write</param>
+            <remarks>
+            <para>
+            Generate XML that is compatible with the log4j schema.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutSchemaLog4j.Version">
+            <summary>
+            The version of the log4j schema to use.
+            </summary>
+            <remarks>
+            <para>
+            Only version 1.2 of the log4j schema is supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.DefaultRenderer">
+            <summary>
+            The default object Renderer.
+            </summary>
+            <remarks>
+            <para>
+            The default renderer supports rendering objects and collections to strings.
+            </para>
+            <para>
+            See the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)"/> method for details of the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ObjectRenderer.IObjectRenderer">
+            <summary>
+            Implement this interface in order to render objects as strings
+            </summary>
+            <remarks>
+            <para>
+            Certain types require special case conversion to
+            string form. This conversion is done by an object renderer.
+            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>
+            interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.IObjectRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a 
+            string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object, TextWriter)"/>
+            method can be used to render these objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)"/>
+            method can be used to render these objects.
+            </para>
+            <para>
+            The default renderer supports rendering objects to strings as follows:
+            </para>
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Rendered String</description>
+            	</listheader>
+            	<item>
+            		<term><c>null</c></term>
+            		<description>
+            		<para>"(null)"</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Array"/></term>
+            		<description>
+            		<para>
+            		For a one dimensional array this is the
+            		array type name, an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace. 
+            		</para>
+            		<para>
+            		For example: <c>int[] {1, 2, 3}</c>.
+            		</para>
+            		<para>
+            		If the array is not one dimensional the 
+            		<c>Array.ToString()</c> is returned.
+            		</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Collections.IEnumerable"/>, <see cref="T:System.Collections.ICollection"/> &amp; <see cref="T:System.Collections.IEnumerator"/></term>
+            		<description>
+            		<para>
+            		Rendered as an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace.
+            		</para>
+            		<para>
+            		For example: <c>{a, b, c}</c>.
+            		</para>
+            		<para>
+            		All collection classes that implement <see cref="T:System.Collections.ICollection"/> its subclasses, 
+            		or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable"/> interface.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term><see cref="T:System.Collections.DictionaryEntry"/></term>
+            		<description>
+            		<para>
+            		Rendered as the key, an equals sign ('='), and the value (using the appropriate
+            		renderer). 
+            		</para>
+            		<para>
+            		For example: <c>key=value</c>.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term>other</term>
+            		<description>
+            		<para><c>Object.ToString()</c></para>
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array,System.IO.TextWriter)">
+            <summary>
+            Render the array argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="array">the array to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            For a one dimensional array this is the
+            array type name, an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>int[] {1, 2, 3}</c>.
+            </para>
+            <para>
+            If the array is not one dimensional the 
+            <c>Array.ToString()</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderEnumerator(log4net.ObjectRenderer.RendererMap,System.Collections.IEnumerator,System.IO.TextWriter)">
+            <summary>
+            Render the enumerator argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="enumerator">the enumerator to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Rendered as an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>{a, b, c}</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderDictionaryEntry(log4net.ObjectRenderer.RendererMap,System.Collections.DictionaryEntry,System.IO.TextWriter)">
+            <summary>
+            Render the DictionaryEntry argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="entry">the DictionaryEntry to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the key, an equals sign ('='), and the value (using the appropriate
+            renderer). For example: <c>key=value</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.RendererMap">
+            <summary>
+            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a mapping between types that require special
+            rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that
+            is used to render them.
+            </para>
+            <para>
+            The <see cref="M:FindAndRender(object)"/> method is used to render an
+            <c>object</c> using the appropriate renderers defined in this map.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <returns>the object rendered as a string</returns>
+            <remarks>
+            <para>
+            This is a convenience method used to render an object to a string.
+            The alternative method <see cref="M:FindAndRender(object,TextWriter)"/>
+            should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Find the appropriate renderer for the type of the
+            <paramref name="obj"/> parameter. This is accomplished by calling the
+            <see cref="M:Get(Type)"/> method. Once a renderer is found, it is
+            applied on the object <paramref name="obj"/> and the result is returned
+            as a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
+            <summary>
+            Gets the renderer for the specified object type
+            </summary>
+            <param name="obj">the object to lookup the renderer for</param>
+            <returns>the renderer for <paramref name="obj"/></returns>
+            <remarks>
+            <param>
+            Gets the renderer for the specified object type.
+            </param>
+            <param>
+            Syntactic sugar method that calls <see cref="M:Get(Type)"/> 
+            with the type of the object parameter.
+            </param>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
+            <summary>
+            Gets the renderer for the specified type
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+            <remarks>
+            <para>
+            Returns the renderer for the specified type.
+            If no specific renderer has been defined the
+            <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">
+            <summary>
+            Internal function to recursively search interfaces
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
+            <summary>
+            Clear the map of renderers
+            </summary>
+            <remarks>
+            <para>
+            Clear the custom renderers defined by using
+            <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>
+            cannot be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>. 
+            </summary>
+            <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>
+            <param name="renderer">the renderer for <paramref name="typeToRender"/></param>
+            <remarks>
+            <para>
+            Register an object renderer for a specific source type.
+            This renderer will be returned from a call to <see cref="M:Get(Type)"/>
+            specifying the same <paramref name="typeToRender"/> as an argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
+            <summary>
+            Get the default renderer instance
+            </summary>
+            <value>the default renderer</value>
+            <remarks>
+            <para>
+            Get the default renderer
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.IPlugin">
+            <summary>
+            Interface implemented by logger repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            Plugins define additional behavior that can be associated
+            with a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The <see cref="T:log4net.Plugin.PluginMap"/> held by the <see cref="P:log4net.Repository.ILoggerRepository.PluginMap"/>
+            property is used to store the plugins for a repository.
+            </para>
+            <para>
+            The <c>log4net.Config.PluginAttribute</c> can be used to
+            attach plugins to repositories created using configuration
+            attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches the plugin to the specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.IPlugin.Name">
+            <summary>
+            Gets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ReadOnly(log4net.Plugin.PluginCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>PluginCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>PluginCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>PluginCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <c>PluginCollection</c>.
+            </summary>
+            <param name="c">The <c>PluginCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.IPlugin[])">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[])">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[],System.Int32)">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the end of the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to be added to the end of the <c>PluginCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clear">
+            <summary>
+            Removes all elements from the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Plugin.PluginCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Contains(log4net.Plugin.IPlugin)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Plugin.IPlugin"/> is in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>PluginCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IndexOf(log4net.Plugin.IPlugin)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Plugin.IPlugin"/>
+            in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to locate in the <c>PluginCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>PluginCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Insert(System.Int32,log4net.Plugin.IPlugin)">
+            <summary>
+            Inserts an element into the <c>PluginCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Plugin.IPlugin"/> from the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the <c>PluginCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Plugin.IPlugin"/> was not found in the <c>PluginCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>PluginCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>PluginCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Plugin.PluginCollection.Enumerator"/> for the entire <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.PluginCollection)">
+            <summary>
+            Adds the elements of another <c>PluginCollection</c> to the current <c>PluginCollection</c>.
+            </summary>
+            <param name="x">The <c>PluginCollection</c> whose elements should be added to the end of the current <c>PluginCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.IPlugin[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> array to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> collection to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the collection.
+            </value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </value>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value><c>true</c> if the collection has a fixed size; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value><c>true</c> if the collection is read-only; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>PluginCollection</c> can contain.
+            </summary>
+            <value>
+            The number of elements the <c>PluginCollection</c> can contain.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Plugin.PluginCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+            <value>
+            The current element in the collection.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.ReadOnlyPluginCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Plugin.PluginMap">
+            <summary>
+            Map of repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            This class is a name keyed map of the plugins that are
+            attached to a repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository that the plugins should be attached to.</param>
+            <remarks>
+            <para>
+            Initialize a new instance of the <see cref="T:log4net.Plugin.PluginMap"/> class with a 
+            repository that the plugins should be attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to add to the map.</param>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Plugin.IPlugin"/> will be attached to the repository when added.
+            </para>
+            <para>
+            If there already exists a plugin with the same name 
+            attached to the repository then the old plugin will
+            be <see cref="M:log4net.Plugin.IPlugin.Shutdown"/> and replaced with
+            the new plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes a <see cref="T:log4net.Plugin.IPlugin"/> from the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the map.</param>
+            <remarks>
+            <para>
+            Remove a specific plugin from this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.Item(System.String)">
+            <summary>
+            Gets a <see cref="T:log4net.Plugin.IPlugin"/> by name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Plugin.IPlugin"/> to lookup.</param>
+            <returns>
+            The <see cref="T:log4net.Plugin.IPlugin"/> from the map with the name specified, or 
+            <c>null</c> if no plugin is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup a plugin by name. If the plugin is not found <c>null</c>
+            will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.AllPlugins">
+            <summary>
+            Gets all possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <value>All possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.</value>
+            <remarks>
+            <para>
+            Get a collection of all the plugins defined in this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginSkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Plugin.IPlugin"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Plugin.IPlugin"/>
+            interface. This base class can be used by implementors
+            of the <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="name">the name of the plugin</param>
+            <remarks>
+            Initializes a new Plugin with the specified name.
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_name">
+            <summary>
+            The name of this plugin.
+            </summary>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_repository">
+            <summary>
+            The repository this plugin is attached to.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.Name">
+            <summary>
+            Gets or sets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            <para>
+            The name of the plugin must not change one the 
+            plugin has been attached to a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.LoggerRepository">
+            <summary>
+            The repository for this plugin
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is attached to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is 
+            attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin">
+            <summary>
+            Plugin that listens for events from the <see cref="T:log4net.Appender.RemotingAppender"/>
+            </summary>
+            <remarks>
+            <para>
+            This plugin publishes an instance of <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/> 
+            on a specified <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/>. This listens for logging events delivered from
+            a remote <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            <para>
+            When an event is received it is relogged within the attached repository
+            as if it had been raised locally.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class.
+            </para>
+            <para>
+            The <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> property must be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor(System.String)">
+            <summary>
+            Construct with sink Uri.
+            </summary>
+            <param name="sinkUri">The name to publish the sink under in the remoting infrastructure. 
+            See <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> for more details.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class
+            with specified name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            When the plugin is shutdown the remote logging
+            sink is disconnected.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.declaringType">
+            <summary>
+            The fully qualified type of the RemoteLoggingServerPlugin class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri">
+            <summary>
+            Gets or sets the URI of this sink.
+            </summary>
+            <value>
+            The URI of this sink.
+            </value>
+            <remarks>
+            <para>
+            This is the name under which the object is marshaled.
+            <see cref="M:RemotingServices.Marshal(MarshalByRefObject,String,Type)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl">
+            <summary>
+            Delivers <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to listen for logging events
+            and deliver them to the local repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository to log to.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl"/> for the
+            specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Logs the events to the repository.
+            </summary>
+            <param name="events">The events to log.</param>
+            <remarks>
+            <para>
+            The events passed are logged to the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.InitializeLifetimeService">
+            <summary>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance.
+            </summary>
+            <returns><c>null</c> to indicate that this instance should live forever.</returns>
+            <remarks>
+            <para>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance. This object should live forever
+            therefore this implementation returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.m_repository">
+            <summary>
+            The underlying <see cref="T:log4net.Repository.ILoggerRepository"/> that events should
+            be logged to.
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">
+            <summary>
+            Default implementation of <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            </summary>
+            <remarks>
+            <para>
+            This default implementation of the <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            interface is used to create the default subclass
+            of the <see cref="T:log4net.Repository.Hierarchy.Logger"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">
+            <summary>
+            Interface abstracts creation of <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances
+            </summary>
+            <remarks>
+            <para>
+            This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to 
+            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.
+            </para>
+            <para>
+            The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)"/> method is called
+            to create a named <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            <para>
+            Implement this interface to create new subclasses of <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl">
+            <summary>
+            Default internal subclass of <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            </summary>
+            <remarks>
+            <para>
+            This subclass has no additional behavior over the
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> class but does allow instances
+            to be created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Logger">
+            <summary>
+            Implementation of <see cref="T:log4net.Core.ILogger"/> used by <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to provide implementation of <see cref="T:log4net.Core.ILogger"/>
+            interface. Applications should use <see cref="T:log4net.LogManager"/> to get
+            logger instances.
+            </para>
+            <para>
+            This is one of the central classes in the log4net implementation. One of the
+            distinctive features of log4net are hierarchical loggers and their
+            evaluation. The <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> organizes the <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            instances into a rooted tree hierarchy.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.Logger"/> class is abstract. Only concrete subclasses of
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> can be created. The <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            is used to create instances of this type for the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">
+            <summary>
+            This constructor created a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance and
+            sets its name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <remarks>
+            <para>
+            This constructor is protected and designed to be used by
+            a subclass that is not abstract.
+            </para>
+            <para>
+            Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> 
+            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default
+            logger creator.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </summary>
+            <param name="newAppender">An appender to add to this logger</param>
+            <remarks>
+            <para>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </para>
+            <para>
+            If <paramref name="newAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">
+            <summary>
+            Look for the appender named as <c>name</c>
+            </summary>
+            <param name="name">The name of the appender to lookup</param>
+            <returns>The appender with the name specified, or <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Returns the named appender, or null if the appender is not found.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">
+            <summary>
+            Remove all previously added appenders from this Logger instance.
+            </summary>
+            <remarks>
+            <para>
+            Remove all previously added appenders from this Logger instance.
+            </para>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the named appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Deliver the <see cref="T:log4net.Core.LoggingEvent"/> to the attached appenders.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Call the appenders in the hierarchy starting at
+            <c>this</c>. If no appenders could be found, emit a
+            warning.
+            </para>
+            <para>
+            This method calls all the appenders inherited from the
+            hierarchy circumventing any evaluation of whether to log or not
+            to log the particular log request.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">
+            <summary>
+            Closes all attached appenders implementing the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Used to ensure that the appenders are correctly shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This is the most generic printing method. This generic form is intended to be used by wrappers
+            </summary>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generates a logging event and delivers it to the attached
+            appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.Core.LoggingEvent)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">
+            <summary>
+            The name of this logger.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">
+            <summary>
+            The assigned level of this logger. 
+            </summary>
+            <remarks>
+            <para>
+            The <c>level</c> variable need not be 
+            assigned a value in which case it is inherited 
+            form the hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">
+            <summary>
+            The parent of this logger.
+            </summary>
+            <remarks>
+            <para>
+            The parent of this logger. 
+            All loggers have at least one ancestor which is the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">
+            <summary>
+            Loggers need to know what Hierarchy they are in.
+            </summary>
+            <remarks>
+            <para>
+            Loggers need to know what Hierarchy they are in.
+            The hierarchy that this logger is a member of is stored
+            here.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderAttachedImpl">
+            <summary>
+            Helper implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">
+            <summary>
+            Flag indicating if child loggers inherit their parents appenders
+            </summary>
+            <remarks>
+            <para>
+            Additivity is set to true by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderLock">
+            <summary>
+            Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl
+            </summary>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">
+            <summary>
+            Gets or sets the parent logger in the hierarchy.
+            </summary>
+            <value>
+            The parent logger in the hierarchy.
+            </value>
+            <remarks>
+            <para>
+            Part of the Composite pattern that makes the hierarchy.
+            The hierarchy is parent linked rather than child linked.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">
+            <summary>
+            Gets or sets a value indicating if child loggers inherit their parent's appenders.
+            </summary>
+            <value>
+            <c>true</c> if child loggers inherit their parent's appenders.
+            </value>
+            <remarks>
+            <para>
+            Additivity is set to <c>true</c> by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.EffectiveLevel">
+            <summary>
+            Gets the effective level for this logger.
+            </summary>
+            <returns>The nearest level in the logger hierarchy.</returns>
+            <remarks>
+            <para>
+            Starting from this logger, searches the logger hierarchy for a
+            non-null level and returns it. Otherwise, returns the level of the
+            root logger.
+            </para>
+            <para>The Logger class is designed so that this method executes as
+            quickly as possible.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>The hierarchy that this logger belongs to.</value>
+            <remarks>
+            <para>
+            This logger must be attached to a single <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.
+            </value>
+            <remarks>
+            <para>
+            The assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> can be <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Appenders">
+            <summary>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <returns>A collection of the appenders in this logger</returns>
+            <remarks>
+            <para>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>. If no appenders 
+            can be found, then a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Name">
+            <summary>
+            Gets the logger name.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl.#ctor(System.String)">
+            <summary>
+            Construct a new Logger
+            </summary>
+            <param name="name">the name of the logger</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl"/> class
+            with the specified name. 
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
+            <summary>
+            Delegate used to handle logger creation event notifications.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> in which the <see cref="T:log4net.Repository.Hierarchy.Logger"/> has been created.</param>
+            <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args that hold the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a
+            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
+            <summary>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument 
+            class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
+            <summary>
+            Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy">
+            <summary>
+            Hierarchical organization of loggers
+            </summary>
+            <remarks>
+            <para>
+            <i>The casual user should not have to deal with this class
+            directly.</i>
+            </para>
+            <para>
+            This class is specialized in retrieving loggers by name and
+            also maintaining the logger hierarchy. Implements the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            The structure of the logger hierarchy is maintained by the
+            <see cref="M:GetLogger(string)"/> method. The hierarchy is such that children
+            link to their parent but parents do not have any references to their
+            children. Moreover, loggers can be instantiated in any order, in
+            particular descendant before ancestor.
+            </para>
+            <para>
+            In case a descendant is created before a particular ancestor,
+            then it creates a provision node for the ancestor and adds itself
+            to the provision node. Other descendants of the same ancestor add
+            themselves to the previously created provision node.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositorySkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.ILoggerRepository">
+            <summary>
+            Interface implemented by logger repositories.
+            </summary>
+            <remarks>
+            <para>
+            This interface is implemented by logger repositories. e.g. 
+            <see cref="N:log4net.Repository.Hierarchy"/>.
+            </para>
+            <para>
+            This interface is used by the <see cref="T:log4net.LogManager"/>
+            to obtain <see cref="T:log4net.ILog"/> interfaces.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
+            <summary>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If the names logger exists it is returned, otherwise
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers as an Array.
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
+            <summary>
+            Returns a named logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Returns a named logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
+            <summary>Shutdown the repository</summary>
+            <remarks>
+            <para>
+            Shutting down a repository will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <see cref="M:Shutdown()"/> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.ConfigurationMessages">
+            <summary>
+            Collection of internal messages captured during the most 
+            recent configuration process.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            <para>
+            These properties can be specified on a repository specific basis.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes the repository with default (empty) properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct the repository using specific properties
+            </summary>
+            <param name="properties">the properties to set for this repository</param>
+            <remarks>
+            <para>
+            Initializes the repository with specified properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
+            <summary>
+            Test if logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the repository
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the repository as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Return a new logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
+            <summary>
+            Shutdown the repository
+            </summary>
+            <remarks>
+            <para>
+            Shutdown the repository. Can be overridden in a subclass.
+            This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>
+            listeners and all attached plugins of the shutdown event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.LoggerRepositorySkeleton.declaringType">
+            <summary>
+            The fully qualified type of the LoggerRepositorySkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Adds an object renderer for a specific class. 
+            </summary>
+            <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>
+            <param name="rendererInstance">The object renderer used to render the object.</param>
+            <remarks>
+            <para>
+            Adds an object renderer for a specific class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository is shutting down
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository is shutting down.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration reset
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has been reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration changed
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">
+            <summary>
+            Raise a configuration changed event on this repository
+            </summary>
+            <param name="e">EventArgs.Empty</param>
+            <remarks>
+            <para>
+            Applications that programmatically change the configuration of the repository should
+            raise this event notification to notify listeners.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes all configured Appenders that implement <see cref="T:log4net.Appender.IFlushable"/>.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed,
+            or <see cref="F:System.Threading.Timeout.Infinite"/> to wait indefinitely.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The string name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of this repository. The name is
+            used to store and lookup the repositories 
+            stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.ConfigurationMessages">
+            <summary>
+            Contains a list of internal messages captures during the 
+            last configuration.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            These properties can be specified on a repository specific basis
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
+            <summary>
+            Basic Configurator interface for repositories
+            </summary>
+            <remarks>
+            <para>
+            Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>
+            with a default <see cref="T:log4net.Appender.IAppender"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the repository using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the repository using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IXmlRepositoryConfigurator">
+            <summary>
+            Configure repository using XML
+            </summary>
+            <remarks>
+            <para>
+            Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the repository using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            The schema for the XML configuration data is defined by
+            the implementation.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct with properties
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with a logger factory
+            </summary>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with properties and a logger factory
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
+            <summary>
+            Test if a logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the hierarchy. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the hierarchy as an Array
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the hierarchy as an Array.
+            The root logger is <b>not</b> included in the returned
+            enumeration.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </summary>
+            <remarks>
+            <para>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
+            <summary>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </summary>
+            <remarks>
+            <para>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <c>Shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
+            <summary>
+            Reset all values contained in this hierarchy instance to their default.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this hierarchy instance to their
+            default.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this hierarchy.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">
+            <summary>
+            Returns all the Appenders that are currently configured
+            </summary>
+            <returns>An array containing all the currently configured appenders</returns>
+            <remarks>
+            <para>
+            Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.
+            All the loggers are searched for appenders. The appenders may also be containers
+            for appenders and these are also searched for additional loggers.
+            </para>
+            <para>
+            The list returned is unordered but does not contain duplicates.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.
+            The appender may also be a container.
+            </summary>
+            <param name="appenderList"></param>
+            <param name="appender"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container
+            </summary>
+            <param name="appenderList"></param>
+            <param name="container"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the log4net system using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">
+            <summary>
+            Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="level">The level to check against.</param>
+            <returns>
+            <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.
+            </returns>
+            <remarks>
+            <para>
+            If this hierarchy has not been configured then this method will
+            always return <c>true</c>.
+            </para>
+            <para>
+            This method will return <c>true</c> if this repository is
+            disabled for <c>level</c> object passed as parameter and
+            <c>false</c> otherwise.
+            </para>
+            <para>
+            See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
+            <summary>
+            Clear all logger definitions from the internal hashtable
+            </summary>
+            <remarks>
+            <para>
+            This call will clear all logger definitions from the internal
+            hashtable. Invoking this method will irrevocably mess up the
+            logger hierarchy.
+            </para>
+            <para>
+            You should <b>really</b> know what you are doing before
+            invoking this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            <paramref name="factory"/>.
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <param name="factory">The factory that will make the new logger instance</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated by the
+            <paramref name="factory"/> parameter and linked with its existing
+            ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Sends a logger creation event to all registered listeners
+            </summary>
+            <param name="logger">The newly created logger</param>
+            <remarks>
+            Raises the logger creation event.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Updates all the parents of the specified logger
+            </summary>
+            <param name="log">The logger to update the parents for</param>
+            <remarks>
+            <para>
+            This method loops through all the <i>potential</i> parents of
+            <paramref name="log"/>. There 3 possible cases:
+            </para>
+            <list type="number">
+            	<item>
+            		<term>No entry for the potential parent of <paramref name="log"/> exists</term>
+            		<description>
+            		We create a ProvisionNode for this potential 
+            		parent and insert <paramref name="log"/> in that provision node.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type Logger for the potential parent.</term>
+            		<description>
+            		The entry is <paramref name="log"/>'s nearest existing parent. We 
+            		update <paramref name="log"/>'s parent field with this entry. We also break from 
+            		he loop because updating our parent's parent is our parent's 
+            		responsibility.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type ProvisionNode for this potential parent.</term>
+            		<description>
+            		We add <paramref name="log"/> to the list of children for this 
+            		potential parent.
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
+            </summary>
+            <param name="pn"></param>
+            <param name="log"></param>
+            <remarks>
+            <para>
+            We update the links for all the children that placed themselves
+            in the provision node 'pn'. The second argument 'log' is a
+            reference for the newly created Logger, parent of all the
+            children in 'pn'.
+            </para>
+            <para>
+            We loop on all the children 'c' in 'pn'.
+            </para>
+            <para>
+            If the child 'c' has been already linked to a child of
+            'log' then there is no need to update 'c'.
+            </para>
+            <para>
+            Otherwise, we set log's parent field to c's parent and set
+            c's parent field to log.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">
+            <summary>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="levelEntry">the level values</param>
+            <remarks>
+            <para>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </para>
+            <para>
+            Supports setting levels via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="propertyEntry">the property value</param>
+            <remarks>
+            <para>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.
+            </para>
+            <para>
+            Supports setting property values via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Hierarchy.declaringType">
+            <summary>
+            The fully qualified type of the Hierarchy class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">
+            <summary>
+            Event used to notify that a logger has been created.
+            </summary>
+            <remarks>
+            <para>
+            Event raised when a logger is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
+            <summary>
+            Has no appender warning been emitted
+            </summary>
+            <remarks>
+            <para>
+            Flag to indicate if we have already issued a warning
+            about not having an appender warning.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
+            <summary>
+            Get the root of this hierarchy
+            </summary>
+            <remarks>
+            <para>
+            Get the root of this hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
+            <summary>
+            Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.
+            </summary>
+            <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>
+            <remarks>
+            <para>
+            The logger factory is used to create logger instances.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">
+            <summary>
+            A class to hold the value, name and display name for a level
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the value, name and display name for a level
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">
+            <summary>
+            Value of the level
+            </summary>
+            <remarks>
+            <para>
+            If the value is not set (defaults to -1) the value will be looked
+            up for the current level with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">
+            <summary>
+            Name of the level
+            </summary>
+            <value>
+            The name of the level
+            </value>
+            <remarks>
+            <para>
+            The name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">
+            <summary>
+            Display name for the level
+            </summary>
+            <value>
+            The display name of the level
+            </value>
+            <remarks>
+            <para>
+            The display name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerKey">
+            <summary>
+            Used internally to accelerate hash table searches.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to improve performance of 
+            string keyed hashtables.
+            </para>
+            <para>
+            The hashcode of the string is cached for reuse.
+            The string is stored as an interned value.
+            When comparing two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> objects for equality 
+            the reference equality of the interned strings is compared.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.#ctor(System.String)">
+            <summary>
+            Construct key with string name
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> class 
+            with the specified name.
+            </para>
+            <para>
+            Stores the hashcode of the string and interns
+            the string key to optimize comparisons.
+            </para>
+            <note>
+            The Compact Framework 1.0 the <see cref="M:System.String.Intern(System.String)"/>
+            method does not work. On the Compact Framework
+            the string keys are not interned nor are they
+            compared by reference.
+            </note>
+            </remarks>
+            <param name="name">The name of the logger.</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.GetHashCode">
+            <summary>
+            Returns a hash code for the current instance.
+            </summary>
+            <returns>A hash code for the current instance.</returns>
+            <remarks>
+            <para>
+            Returns the cached hashcode.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.Equals(System.Object)">
+            <summary>
+            Determines whether two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> instances 
+            are equal.
+            </summary>
+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>.</param>
+            <returns>
+            <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>.
+            </returns>
+            <remarks>
+            <para>
+            Compares the references of the interned strings.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">
+            <summary>
+            Provision nodes are used where no logger instance has been specified
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> instances are used in the 
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> when there is no specified 
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> for that node.
+            </para>
+            <para>
+            A provision node holds a list of child loggers on behalf of
+            a logger that does not exist.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Create a new provision node with child node
+            </summary>
+            <param name="log">A child logger to add to this node.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> class 
+            with the specified child logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.RootLogger">
+            <summary>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> sits at the root of the logger hierarchy tree. 
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> is a regular <see cref="T:log4net.Repository.Hierarchy.Logger"/> except 
+            that it provides several guarantees.
+            </para>
+            <para>
+            First, it cannot be assigned a <c>null</c>
+            level. Second, since the root logger cannot have a parent, the
+            <see cref="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel"/> property always returns the value of the
+            level field without walking the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.Core.Level)">
+            <summary>
+            Construct a <see cref="T:log4net.Repository.Hierarchy.RootLogger"/>
+            </summary>
+            <param name="level">The level to assign to the root logger.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> class with
+            the specified logging level.
+            </para>
+            <para>
+            The root logger names itself as "root". However, the root
+            logger cannot be retrieved by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.RootLogger.declaringType">
+            <summary>
+            The fully qualified type of the RootLogger class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel">
+            <summary>
+            Gets the assigned level value without walking the logger hierarchy.
+            </summary>
+            <value>The assigned level value without walking the logger hierarchy.</value>
+            <remarks>
+            <para>
+            Because the root logger cannot have a parent and its level
+            must not be <c>null</c> this property just returns the
+            value of <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> for the root logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> of the root logger.
+            </value>
+            <remarks>
+            <para>
+            Setting the level of the root logger to a <c>null</c> reference
+            may have catastrophic results. We prevent this here.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator">
+            <summary>
+            Initializes the log4net environment using an XML DOM.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.#ctor(log4net.Repository.Hierarchy.Hierarchy)">
+            <summary>
+            Construct the configurator for a hierarchy
+            </summary>
+            <param name="hierarchy">The hierarchy to build.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator"/> class
+            with the specified <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </summary>
+            <param name="element">The root element to parse.</param>
+            <remarks>
+            <para>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">
+            <summary>
+            Parse appenders by IDREF.
+            </summary>
+            <param name="appenderRef">The appender ref element.</param>
+            <returns>The instance of the appender that the ref refers to.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return 
+            the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">
+            <summary>
+            Parses an appender element.
+            </summary>
+            <param name="appenderElement">The appender element.</param>
+            <returns>The appender instance or <c>null</c> when parsing failed.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return
+            the appender instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLogger(System.Xml.XmlElement)">
+            <summary>
+            Parses a logger element.
+            </summary>
+            <param name="loggerElement">The logger element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRoot(System.Xml.XmlElement)">
+            <summary>
+            Parses the root logger element.
+            </summary>
+            <param name="rootElement">The root element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses the children of a logger element.
+            </summary>
+            <param name="catElement">The category element.</param>
+            <param name="log">The logger instance.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse the child elements of a &lt;logger&gt; element.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement)">
+            <summary>
+            Parses an object renderer.
+            </summary>
+            <param name="element">The renderer element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a renderer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses a level element.
+            </summary>
+            <param name="element">The level element.</param>
+            <param name="log">The logger object to set the level on.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">
+            <summary>
+            Sets a parameter on an object.
+            </summary>
+            <param name="element">The parameter element.</param>
+            <param name="target">The object to set the parameter on.</param>
+            <remarks>
+            The parameter name must correspond to a writable property
+            on the object. The value of the parameter is a string,
+            therefore this function will attempt to set a string
+            property first. If unable to set a string property it
+            will inspect the property and its argument type. It will
+            attempt to call a static method called <c>Parse</c> on the
+            type of the property. This method will take a single
+            string argument and return a value that can be used to
+            set the property.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.HasAttributesOrElements(System.Xml.XmlElement)">
+            <summary>
+            Test if an element has no attributes or child elements
+            </summary>
+            <param name="element">the element to inspect</param>
+            <returns><c>true</c> if the element has any attributes or child elements, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.IsTypeConstructible(System.Type)">
+            <summary>
+            Test if a <see cref="T:System.Type"/> is constructible with <c>Activator.CreateInstance</c>.
+            </summary>
+            <param name="type">the type to inspect</param>
+            <returns><c>true</c> if the type is creatable using a default constructor, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindMethodInfo(System.Type,System.String)">
+            <summary>
+            Look for a method on the <paramref name="targetType"/> that matches the <paramref name="name"/> supplied
+            </summary>
+            <param name="targetType">the type that has the method</param>
+            <param name="name">the name of the method</param>
+            <returns>the method info found</returns>
+            <remarks>
+            <para>
+            The method must be a public instance method on the <paramref name="targetType"/>.
+            The method must be named <paramref name="name"/> or "Add" followed by <paramref name="name"/>.
+            The method must take a single parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string value to a target type.
+            </summary>
+            <param name="type">The type of object to convert the string to.</param>
+            <param name="value">The string value to use as the value of the object.</param>
+            <returns>
+            <para>
+            An object of type <paramref name="type"/> with value <paramref name="value"/> or 
+            <c>null</c> when the conversion could not be performed.
+            </para>
+            </returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement,System.Type,System.Type)">
+            <summary>
+            Creates an object as specified in XML.
+            </summary>
+            <param name="element">The XML element that contains the definition of the object.</param>
+            <param name="defaultTargetType">The object type to use if not explicitly specified.</param>
+            <param name="typeConstraint">The type that the returned object must be or must inherit from.</param>
+            <returns>The object or <c>null</c></returns>
+            <remarks>
+            <para>
+            Parse an XML element and create an object instance based on the configuration
+            data.
+            </para>
+            <para>
+            The type of the instance may be specified in the XML. If not
+            specified then the <paramref name="defaultTargetType"/> is used
+            as the type. However the type is specified it must support the
+            <paramref name="typeConstraint"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_appenderBag">
+            <summary>
+            key: appenderName, value: appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_hierarchy">
+            <summary>
+            The Hierarchy being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlHierarchyConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.ConfigurationChangedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.ConfigurationChangedEventArgs.#ctor(System.Collections.ICollection)">
+            <summary>
+            
+            </summary>
+            <param name="configurationMessages"></param>
+        </member>
+        <member name="P:log4net.Repository.ConfigurationChangedEventArgs.ConfigurationMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryShutdownEventHandler">
+            <summary>
+            Delegate used to handle logger repository shutdown event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository shutdown event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationResetEventHandler">
+            <summary>
+            Delegate used to handle logger repository configuration reset event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration reset.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository configuration reset event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationChangedEventHandler">
+            <summary>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration changed.</param>
+            <param name="e">Empty event arguments.</param>
+            <remarks>
+            <para>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppDomainPatternConverter">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the name of the current AppDomain to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppDomainPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes name of the current AppDomain to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppSettingPatternConverter">
+            <summary>
+            AppSetting pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads appSettings from the application configuration file.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single appSettings value. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all appSettings will be dumped as a list of key value pairs.
+            </para>
+            <para>
+            A typical use is to specify a base directory for log files, e.g.
+            <example>
+            <![CDATA[
+            <log4net>
+               <appender name="MyAppender" type="log4net.Appender.RollingFileAppender">
+                 <file type="log4net.Util.PatternString" value="appsetting{LogDirectory}MyApp.log"/>
+                  ...
+              </appender>
+            </log4net>
+            ]]>
+            </example>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppSettingPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.DatePatternConverter">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The date and time is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date and time passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter">
+            <summary>
+            Write an <see cref="T:System.Environment.SpecialFolder"/> folder path to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an special path environment folder path to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output. <see cref="P:log4net.Util.PatternConverter.Option"/>
+            should be a value in the <see cref="T:System.Environment.SpecialFolder"/> enumeration.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an special path environment folder path to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the special path environment folder path to the output <paramref name="writer"/>.
+            The name of the special path environment folder path to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentFolderPathPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentPatternConverter">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an environment variable to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the environment variable to the output <paramref name="writer"/>.
+            The name of the environment variable to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.IdentityPatternConverter">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current thread identity to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.IdentityPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the current thread identity to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.IdentityPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the IdentityPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">
+            <summary>
+            Pattern converter for literal string instances in the pattern
+            </summary>
+            <remarks>
+            <para>
+            Writes the literal string value specified in the 
+            <see cref="P:log4net.Util.PatternConverter.Option"/> property to 
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next converter in the chain
+            </summary>
+            <param name="pc">The next pattern converter in the chain</param>
+            <returns>The next pattern converter</returns>
+            <remarks>
+            <para>
+            Special case the building of the pattern converter chain
+            for <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> instances. Two adjacent
+            literals in the pattern can be represented by a single combined
+            pattern converter. This implementation detects when a 
+            <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> is added to the chain
+            after this converter and combines its value with this converter's
+            literal value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the literal to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            Override the formatting behavior to ignore the FormattingInfo
+            because we have a literal instead.
+            </para>
+            <para>
+            Writes the value of <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Convert this pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            This method is not used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.NewLinePatternConverter">
+            <summary>
+            Writes a newline to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the system dependent line terminator to the output.
+            This behavior can be overridden by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>:
+            </para>
+            <list type="definition">
+              <listheader>
+                <term>Option Value</term>
+                <description>Output</description>
+              </listheader>
+              <item>
+                <term>DOS</term>
+                <description>DOS or Windows line terminator <c>"\r\n"</c></description>
+              </item>
+              <item>
+                <term>UNIX</term>
+                <description>UNIX line terminator <c>"\n"</c></description>
+              </item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.ProcessIdPatternConverter">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current process ID to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current process ID to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the ProcessIdPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads the thread and global properties.
+            The thread properties take priority over global properties.
+            See <see cref="P:log4net.ThreadContext.Properties"/> for details of the 
+            thread properties. See <see cref="P:log4net.GlobalContext.Properties"/> for
+            details of the global properties.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single property. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all properties will be dumped as a list of key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.PropertyPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.RandomStringPatternConverter">
+            <summary>
+            A Pattern converter that generates a string of random characters
+            </summary>
+            <remarks>
+            <para>
+            The converter generates a string of random characters. By default
+            the string is length 4. This can be changed by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the string value of the length required.
+            </para>
+            <para>
+            The random characters in the string are limited to uppercase letters
+            and numbers only.
+            </para>
+            <para>
+            The random number generator used by this class is not cryptographically secure.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.s_random">
+            <summary>
+            Shared random number generator
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.m_length">
+            <summary>
+            Length of random string to generate. Default length 4.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write a randoim string to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write a randoim string to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the RandomStringPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UserNamePatternConverter">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current threads username to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UserNamePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current threads username to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UserNamePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UserNamePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter">
+            <summary>
+            Write the UTC date time to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UtcDatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date and time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date is in Universal time when it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.BooleanConverter">
+            <summary>
+            Type converter for Boolean.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <c>bool</c> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            <summary>
+            Exception base type for conversion errors.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConverterRegistry">
+            <summary>
+            Register of type converters for specific types.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a registry of type converters used to convert between
+            types.
+            </para>
+            <para>
+            Use the <see cref="M:AddConverter(Type, object)"/> and 
+            <see cref="M:AddConverter(Type, Type)"/> methods to register new converters.
+            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
+            lookup appropriate converters to use.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConverterRegistry"/> class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#cctor">
+            <summary>
+            Static constructor.
+            </summary>
+            <remarks>
+            <para>
+            This constructor defines the intrinsic type converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Object)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converter">The type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter instance for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Type)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converterType">The type of the type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter <see cref="T:System.Type"/> for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="sourceType">The type being converted from.</param>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConverterFromAttribute(System.Type)">
+            <summary>
+            Lookups the type converter to use as specified by the attributes on the 
+            destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.CreateConverterInstance(System.Type)">
+            <summary>
+            Creates the instance of the type converter.
+            </summary>
+            <param name="converterType">The type of the type converter.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            The type specified for the type converter must implement 
+            the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> or <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces 
+            and must have a public default (no argument) constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.declaringType">
+            <summary>
+            The fully qualified type of the ConverterRegistry class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.s_type2converter">
+            <summary>
+            Mapping from <see cref="T:System.Type"/> to type converter.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.EncodingConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an encoding</param>
+            <returns>the encoding</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to 
+            convert the <see cref="T:System.String"/> argument to an <see cref="T:System.Text.Encoding"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertTo">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from a single type to arbitrary types.
+            See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.CanConvertTo(System.Type)">
+            <summary>
+            Returns whether this converter can convert the object to the specified type
+            </summary>
+            <param name="targetType">A Type that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the type supported by this converter can be converted to the
+            <paramref name="targetType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> (which must be of the type supported
+            by this converter) to the <paramref name="targetType"/> specified..
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IPAddressConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an IPAddress</param>
+            <returns>the IPAddress</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Net.IPAddress.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to an <see cref="T:System.Net.IPAddress"/>.
+            If that fails then the string is resolved as a DNS hostname.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.IPAddressConverter.validIpAddressChars">
+            <summary>
+            Valid characters in an IPv4 or IPv6 address string. (Does not support subnets)
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternLayoutConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> 
+            of the <see cref="T:log4net.Layout.PatternLayout"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternLayout</param>
+            <returns>the PatternLayout</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Layout.PatternLayout"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternStringConverter">
+            <summary>
+            Convert between string and <see cref="T:log4net.Util.PatternString"/>
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Util.PatternString"/> type, 
+            and from a <see cref="T:log4net.Util.PatternString"/> type to a string.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Util.PatternString.ConversionPattern"/> 
+            of the <see cref="T:log4net.Util.PatternString"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)">
+            <summary>
+            Can the target type be converted to the type supported by this object
+            </summary>
+            <param name="targetType">A <see cref="T:System.Type"/> that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="targetType"/> is
+            assignable from a <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:PatternString.Format()"/> method to convert the
+            <see cref="T:log4net.Util.PatternString"/> argument to a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            <paramref name="targetType"/>. To check for this condition use the 
+            <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)"/> method.
+            </exception>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternString</param>
+            <returns>the PatternString</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Util.PatternString"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Util.PatternString.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a Type</param>
+            <returns>the Type</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Type"/>.
+            Additional effort is made to locate partially specified types
+            by searching the loaded assemblies.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">
+            <summary>
+            Attribute used to associate a type converter
+            </summary>
+            <remarks>
+            <para>
+            Class and Interface level attribute that specifies a type converter
+            to use with the associated type.
+            </para>
+            <para>
+            To associate a type converter with a target type apply a
+            <c>TypeConverterAttribute</c> to the target type. Specify the
+            type of the type converter on the attribute.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">
+            <summary>
+            The string type name of the type converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">
+            <summary>
+            Create a new type converter attribute for the specified type name
+            </summary>
+            <param name="typeName">The string type name of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">
+            <summary>
+            Create a new type converter attribute for the specified type
+            </summary>
+            <param name="converterType">The type of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">
+            <summary>
+            The string type name of the type converter 
+            </summary>
+            <value>
+            The string type name of the type converter 
+            </value>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.AppenderAttachedImpl">
+            <summary>
+            A straightforward implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This is the default implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/>
+            interface. Implementors of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            should aggregate an instance of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.AppenderAttachedImpl"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvents">The array of events being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.CallAppend(log4net.Appender.IAppender,log4net.Core.LoggingEvent[])">
+            <summary>
+            Calls the DoAppende method on the <see cref="T:log4net.Appender.IAppender"/> with 
+            the <see cref="T:log4net.Core.LoggingEvent"/> objects supplied.
+            </summary>
+            <param name="appender">The appender</param>
+            <param name="loggingEvents">The events</param>
+            <remarks>
+            <para>
+            If the <paramref name="appender"/> supports the <see cref="T:log4net.Appender.IBulkAppender"/>
+            interface then the <paramref name="loggingEvents"/> will be passed 
+            through using that interface. Otherwise the <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the array will be passed one at a time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="newAppender">The appender to add.</param>
+            <remarks>
+            <para>
+            If the appender is already in the list it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup an attached appender by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderList">
+            <summary>
+            List of appenders
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderArray">
+            <summary>
+            Array of appenders, used to cache the m_appenderList
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.declaringType">
+            <summary>
+            The fully qualified type of the AppenderAttachedImpl class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.AppenderAttachedImpl.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <returns>
+            A collection of attached appenders, or <c>null</c> if there
+            are no attached appenders.
+            </returns>
+            <remarks>
+            <para>
+            The read only collection of all currently attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CompositeProperties">
+            <summary>
+            This class aggregates several PropertiesDictionary collections together.
+            </summary>
+            <remarks>
+            <para>
+            Provides a dictionary style lookup over an ordered list of
+            <see cref="T:log4net.Util.PropertiesDictionary"/> collections.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CompositeProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Add(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Add a Properties Dictionary to this composite collection
+            </summary>
+            <param name="properties">the properties to add</param>
+            <remarks>
+            <para>
+            Properties dictionaries added first take precedence over dictionaries added
+            later.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Flatten">
+            <summary>
+            Flatten this composite collection into a single properties dictionary
+            </summary>
+            <returns>the flattened dictionary</returns>
+            <remarks>
+            <para>
+            Reduces the collection of ordered dictionaries to a single dictionary
+            containing the resultant values for the keys.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CompositeProperties.Item(System.String)">
+            <summary>
+            Gets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Looks up the value for the <paramref name="key"/> specified.
+            The <see cref="T:log4net.Util.PropertiesDictionary"/> collections are searched
+            in the order in which they were added to this collection. The value
+            returned is the value held by the first collection that contains
+            the specified key.
+            </para>
+            <para>
+            If none of the collections contain the specified key then
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ContextPropertiesBase">
+            <summary>
+            Base class for Context Properties implementations
+            </summary>
+            <remarks>
+            <para>
+            This class defines a basic property get set accessor
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ConverterInfo">
+            <summary>
+            Wrapper class used to map converter names to converter types
+            </summary>
+            <remarks>
+            <para>
+            Pattern converter info class used during configuration by custom
+            PatternString and PatternLayer converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.#ctor">
+            <summary>
+            default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            
+            </summary>
+            <param name="entry"></param>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Name">
+            <summary>
+            Gets or sets the name of the conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            The name of the pattern in the format string
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Type">
+            <summary>
+            Gets or sets the type of the converter
+            </summary>
+            <remarks>
+            <para>
+            The value specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.CountingQuietTextWriter">
+            <summary>
+            Subclass of <see cref="T:log4net.Util.QuietTextWriter"/> that maintains a count of 
+            the number of bytes written.
+            </summary>
+            <remarks>
+            <para>
+            This writer counts the number of bytes written.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.QuietTextWriter">
+            <summary>
+            <see cref="T:System.IO.TextWriter"/> that does not leak exceptions
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Util.QuietTextWriter"/> does not throw exceptions when things go wrong. 
+            Instead, it delegates error handling to its <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TextWriterAdapter">
+            <summary>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.TextWriterAdapter.m_writer">
+            <summary>
+            The writer to forward messages to
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Close">
+            <summary>
+            Closes the writer and releases any system resources associated with the writer
+            </summary>
+            <remarks>
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">
+            <summary>
+            Dispose this writer
+            </summary>
+            <param name="disposing">flag indicating if we are being disposed</param>
+            <remarks>
+            <para>
+            Dispose this writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Flush">
+            <summary>
+            Flushes any buffered output
+            </summary>
+            <remarks>
+            <para>
+            Clears all buffers for the writer and causes any buffered data to be written 
+            to the underlying device
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">
+            <summary>
+            Writes a character to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a character to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a character buffer to the wrapped TextWriter
+            </summary>
+            <param name="buffer">the data buffer</param>
+            <param name="index">the start index</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a character buffer to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">
+            <summary>
+            Writes a string to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a string to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Writer">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.IO.TextWriter"/>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Encoding">
+            <summary>
+            The Encoding in which the output is written
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>
+            </value>
+            <remarks>
+            <para>
+            The Encoding in which the output is written
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">
+            <summary>
+            Gets an object that controls formatting
+            </summary>
+            <value>
+            The format provider
+            </value>
+            <remarks>
+            <para>
+            Gets an object that controls formatting
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.NewLine">
+            <summary>
+            Gets or sets the line terminator string used by the TextWriter
+            </summary>
+            <value>
+            The line terminator to use
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the line terminator string used by the TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <param name="errorHandler">the error handler to report error to</param>
+            <remarks>
+            <para>
+            Create a new QuietTextWriter using a writer and error handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Writes a character to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a buffer to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output.
+            </summary>
+            <param name="value">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Writes a string to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Close">
+            <summary>
+            Closes the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_errorHandler">
+            <summary>
+            The error handler instance to pass all errors to
+            </summary>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_closed">
+            <summary>
+            Flag to indicate if this writer is closed
+            </summary>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.ErrorHandler">
+            <summary>
+            Gets or sets the error handler that all errors are passed to.
+            </summary>
+            <value>
+            The error handler that all errors are passed to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the error handler that all errors are passed to.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.Closed">
+            <summary>
+            Gets a value indicating whether this writer is closed.
+            </summary>
+            <value>
+            <c>true</c> if this writer is closed, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets a value indicating whether this writer is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to actually write to.</param>
+            <param name="errorHandler">The <see cref="T:log4net.Core.IErrorHandler"/> to report errors to.</param>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.CountingQuietTextWriter"/> class 
+            with the specified <see cref="T:System.IO.TextWriter"/> and <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output and counts the number of bytes written.
+            </summary>
+            <param name="str">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.CountingQuietTextWriter.m_countBytes">
+            <summary>
+            Total number of bytes written.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.CountingQuietTextWriter.Count">
+            <summary>
+            Gets or sets the total number of bytes written.
+            </summary>
+            <value>
+            The total number of bytes written.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the total number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CyclicBuffer">
+            <summary>
+            A fixed size rolling buffer of logging events.
+            </summary>
+            <remarks>
+            <para>
+            An array backed fixed size leaky bucket.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="maxSize">The maximum number of logging events in the buffer.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with 
+            the specified maximum number of buffered logging events.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Appends a <paramref name="loggingEvent"/> to the buffer.
+            </summary>
+            <param name="loggingEvent">The event to append to the buffer.</param>
+            <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Append an event to the buffer. If the buffer still contains free space then
+            <c>null</c> is returned. If the buffer is full then an event will be dropped
+            to make space for the new event, the event dropped is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopOldest">
+            <summary>
+            Get and remove the oldest event in the buffer.
+            </summary>
+            <returns>The oldest logging event in the buffer</returns>
+            <remarks>
+            <para>
+            Gets the oldest (first) logging event in the buffer and removes it 
+            from the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopAll">
+            <summary>
+            Pops all the logging events from the buffer into an array.
+            </summary>
+            <returns>An array of all the logging events in the buffer.</returns>
+            <remarks>
+            <para>
+            Get all the events in the buffer and clear the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Clear">
+            <summary>
+            Clear the buffer
+            </summary>
+            <remarks>
+            <para>
+            Clear the buffer of all events. The events in the buffer are lost.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">
+            <summary>
+            Gets the <paramref name="i"/>th oldest event currently in the buffer.
+            </summary>
+            <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>
+            <remarks>
+            <para>
+            If <paramref name="i"/> is outside the range 0 to the number of events
+            currently in the buffer, then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.MaxSize">
+            <summary>
+            Gets the maximum size of the buffer.
+            </summary>
+            <value>The maximum size of the buffer.</value>
+            <remarks>
+            <para>
+            Gets the maximum size of the buffer
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Length">
+            <summary>
+            Gets the number of logging events in the buffer.
+            </summary>
+            <value>The number of logging events in the buffer.</value>
+            <remarks>
+            <para>
+            This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>
+            (inclusive).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyCollection">
+            <summary>
+            An always empty <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.ICollection"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyCollection"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.EmptyCollection.s_instance">
+            <summary>
+            The singleton instance of the empty collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Instance">
+            <summary>
+            Gets the singleton instance of the empty collection.
+            </summary>
+            <returns>The singleton instance of the empty collection.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the empty collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyCollection.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyCollection.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyDictionary">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionary"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyDictionary"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Add(System.Object,System.Object)">
+            <summary>
+            Adds an element with the provided key and value to the 
+            <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>
+            <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>
+            <remarks>
+            <para>
+            As the collection is empty no new values can be added. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Clear">
+            <summary>
+            Removes all elements from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Contains(System.Object)">
+            <summary>
+            Determines whether the <see cref="T:log4net.Util.EmptyDictionary"/> contains an element 
+            with the specified key.
+            </summary>
+            <param name="key">The key to locate in the <see cref="T:log4net.Util.EmptyDictionary"/>.</param>
+            <returns><c>false</c></returns>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="M:log4net.Util.EmptyDictionary.Contains(System.Object)"/> method always returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Remove(System.Object)">
+            <summary>
+            Removes the element with the specified key from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The key of the element to remove.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="F:log4net.Util.EmptyDictionary.s_instance">
+            <summary>
+            The singleton instance of the empty dictionary.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <b>true</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyDictionary.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyDictionary.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> has a fixed size.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsFixedSize"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> is read-only.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsReadOnly"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Keys">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Values">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Item(System.Object)">
+            <summary>
+            Gets or sets the element with the specified key.
+            </summary>
+            <param name="key">The key of the element to get or set.</param>
+            <value><c>null</c></value>
+            <remarks>
+            <para>
+            As the collection is empty no values can be looked up or stored. 
+            If the index getter is called then <c>null</c> is returned.
+            A <see cref="T:System.InvalidOperationException"/> is thrown if the setter is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="T:log4net.Util.FormattingInfo">
+            <summary>
+            Contain the information obtained when parsing formatting modifiers 
+            in conversion modifiers.
+            </summary>
+            <remarks>
+            <para>
+            Holds the formatting information extracted from the format string by
+            the <see cref="T:log4net.Util.PatternParser"/>. This is used by the <see cref="T:log4net.Util.PatternConverter"/>
+            objects when rendering the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor">
+            <summary>
+            Defaut Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor(System.Int32,System.Int32,System.Boolean)">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class
+            with the specified parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Min">
+            <summary>
+            Gets or sets the minimum value.
+            </summary>
+            <value>
+            The minimum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the minimum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Max">
+            <summary>
+            Gets or sets the maximum value.
+            </summary>
+            <value>
+            The maximum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the maximum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.LeftAlign">
+            <summary>
+            Gets or sets a flag indicating whether left align is enabled
+            or not.
+            </summary>
+            <value>
+            A flag indicating whether left align is enabled or not.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a flag indicating whether left align is enabled or not.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.GlobalContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.GlobalContext"/>
+            </summary>
+            <remarks>
+            <para>
+            This class implements a properties collection that is thread safe and supports both
+            storing properties and capturing a read only copy of the current propertied.
+            </para>
+            <para>
+            This class is optimized to the scenario where the properties are read frequently
+            and are modified infrequently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_readOnlyProperties">
+            <summary>
+            The read only copy of the properties.
+            </summary>
+            <remarks>
+            <para>
+            This variable is declared <c>volatile</c> to prevent the compiler and JIT from
+            reordering reads and writes of this thread performed on different threads.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_syncRoot">
+            <summary>
+            Lock object used to synchronize updates within this instance
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.GlobalContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property from the global context
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Removing an entry from the global context properties is relatively expensive compared
+            with reading a value. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Clear">
+            <summary>
+            Clear the global context properties
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.GetReadOnlyProperties">
+            <summary>
+            Get a readonly immutable copy of the properties
+            </summary>
+            <returns>the current global context properties</returns>
+            <remarks>
+            <para>
+            This implementation is fast because the GlobalContextProperties class
+            stores a readonly copy of the properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.GlobalContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Reading the value for a key is faster than setting the value.
+            When the value is written a new read only copy of 
+            the properties is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMapping">
+            <summary>
+            Manages a mapping from levels to <see cref="T:log4net.Util.LevelMappingEntry"/>
+            </summary>
+            <remarks>
+            <para>
+            Manages an ordered mapping from <see cref="T:log4net.Core.Level"/> instances 
+            to <see cref="T:log4net.Util.LevelMappingEntry"/> subclasses.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialise a new instance of <see cref="T:log4net.Util.LevelMapping"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Add(log4net.Util.LevelMappingEntry)">
+            <summary>
+            Add a <see cref="T:log4net.Util.LevelMappingEntry"/> to this mapping
+            </summary>
+            <param name="entry">the entry to add</param>
+            <remarks>
+            <para>
+            If a <see cref="T:log4net.Util.LevelMappingEntry"/> has previously been added
+            for the same <see cref="T:log4net.Core.Level"/> then that entry will be 
+            overwritten.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Lookup(log4net.Core.Level)">
+            <summary>
+            Lookup the mapping for the specified level
+            </summary>
+            <param name="level">the level to lookup</param>
+            <returns>the <see cref="T:log4net.Util.LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
+            <remarks>
+            <para>
+            Lookup the value for the specified level. Finds the nearest
+            mapping value for the level that is equal to or less than the
+            <paramref name="level"/> specified.
+            </para>
+            <para>
+            If no mapping could be found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.ActivateOptions">
+            <summary>
+            Initialize options
+            </summary>
+            <remarks>
+            <para>
+            Caches the sorted list of <see cref="T:log4net.Util.LevelMappingEntry"/> in an array
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            <para>
+            This class stores its properties in a slot on the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> named
+            <c>log4net.Util.LogicalThreadContextProperties</c>.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.m_disabled">
+            <summary>
+            Flag used to disable this context if we don't have permission to access the CallContext.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the value for the specified <paramref name="key"/> from the context.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Clear">
+            <summary>
+            Clear all the context properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all the context properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the PropertiesDictionary stored in the LocalDataStoreSlot for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doings so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetLogicalProperties">
+            <summary>
+            Gets the call context get data.
+            </summary>
+            <returns>The peroperties dictionary stored in the call context</returns>
+            <remarks>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.GetData(System.String)"/> has a
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.SetLogicalProperties(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Sets the call context data.
+            </summary>
+            <param name="properties">The properties.</param>
+            <remarks>
+            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
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.declaringType">
+            <summary>
+            The fully qualified type of the LogicalThreadContextProperties class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Get or set the property value for the <paramref name="key"/> specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TwoArgAction`2">
+            <summary>
+            Delegate type used for LogicalThreadContextStack's callbacks.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_propertyKey">
+            <summary>
+            The name of this <see cref="T:log4net.Util.LogicalThreadContextStack"/> within the
+            <see cref="T:log4net.Util.LogicalThreadContextProperties"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_registerNew">
+            <summary>
+            The callback used to let the <see cref="T:log4net.Util.LogicalThreadContextStacks"/> register a
+            new instance of a <see cref="T:log4net.Util.LogicalThreadContextStack"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.#ctor(System.String,log4net.Util.TwoArgAction{System.String,log4net.Util.LogicalThreadContextStack})">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this thread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.LogicalThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.LogicalThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_logicalThreadContextStack">
+            <summary>
+            The outer LogicalThreadContextStack.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.#ctor(log4net.Util.LogicalThreadContextStack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="logicalThreadContextStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStacks.#ctor(log4net.Util.LogicalThreadContextProperties)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventHandler">
+            <summary>
+            
+            </summary>
+            <param name="source"></param>
+            <param name="e"></param>
+        </member>
+        <member name="T:log4net.Util.LogLog">
+            <summary>
+            Outputs log statements from within the log4net assembly.
+            </summary>
+            <remarks>
+            <para>
+            Log4net components cannot make log4net logging calls. However, it is
+            sometimes useful for the user to learn about what log4net is
+            doing.
+            </para>
+            <para>
+            All log4net internal debug calls go to the standard output stream
+            whereas internal error messages are sent to the standard error output 
+            stream.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.LogLog.ToString">
+            <summary>
+            Formats Prefix, Source, and Message in the same format as the value
+            sent to Console.Out and Trace.Write.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.LogLog.#ctor(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogLog"/> class. 
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.#cctor">
+            <summary>
+            Static constructor that initializes logging by reading 
+            settings from the application configuration file.
+            </summary>
+            <remarks>
+            <para>
+            The <c>log4net.Internal.Debug</c> application setting
+            controls internal debugging. This setting should be set
+            to <c>true</c> to enable debugging.
+            </para>
+            <para>
+            The <c>log4net.Internal.Quiet</c> application setting
+            suppresses all internal logging including error messages. 
+            This setting should be set to <c>true</c> to enable message
+            suppression.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.OnLogReceived(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Raises the LogReceived event when an internal messages is received.
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source"></param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal error messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitOutLine(System.String)">
+            <summary>
+            Writes output to the standard output stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Out and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitErrorLine(System.String)">
+            <summary>
+            Writes output to the standard error stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Error and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_debugEnabled">
+            <summary>
+             Default debug level
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_quietMode">
+            <summary>
+            In quietMode not even errors generate any output.
+            </summary>
+        </member>
+        <member name="E:log4net.Util.LogLog.LogReceived">
+            <summary>
+            The event raised when an internal message has been received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Source">
+            <summary>
+            The Type that generated the internal message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStamp">
+            <summary>
+            The DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStampUtc">
+            <summary>
+            The UTC DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Prefix">
+            <summary>
+            A string indicating the severity of the internal message.
+            </summary>
+            <remarks>
+            "log4net: ", 
+            "log4net:ERROR ", 
+            "log4net:WARN "
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.Message">
+            <summary>
+            The internal log message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Exception">
+            <summary>
+            The Exception related to the message.
+            </summary>
+            <remarks>
+            Optional. Will be null if no Exception was passed.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.InternalDebugging">
+            <summary>
+            Gets or sets a value indicating whether log4net internal logging
+            is enabled or disabled.
+            </summary>
+            <value>
+            <c>true</c> if log4net internal logging is enabled, otherwise 
+            <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c>, internal debug level logging will be 
+            displayed.
+            </para>
+            <para>
+            This value can be set by setting the application setting 
+            <c>log4net.Internal.Debug</c> in the application configuration
+            file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. debugging is
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            The following example enables internal debugging using the 
+            application configuration file :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Debug" value="true" />
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.QuietMode">
+            <summary>
+            Gets or sets a value indicating whether log4net should generate no output
+            from internal logging, not even for errors. 
+            </summary>
+            <value>
+            <c>true</c> if log4net should generate no output at all from internal 
+            logging, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c> will cause internal logging at all levels to be 
+            suppressed. This means that no warning or error reports will be logged. 
+            This option overrides the <see cref="P:log4net.Util.LogLog.InternalDebugging"/> setting and 
+            disables all debug also.
+            </para>
+            <para>This value can be set by setting the application setting
+            <c>log4net.Internal.Quiet</c> in the application configuration file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. internal logging is not
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            The following example disables internal logging using the 
+            application configuration file :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Quiet" value="true"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.EmitInternalMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsDebugEnabled">
+            <summary>
+            Test if LogLog.Debug is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Debug is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Debug is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsWarnEnabled">
+            <summary>
+            Test if LogLog.Warn is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Warn is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Warn is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsErrorEnabled">
+            <summary>
+            Test if LogLog.Error is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Error is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Error is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogLog.LogReceivedAdapter">
+            <summary>
+            Subscribes to the LogLog.LogReceived event and stores messages
+            to the supplied IList instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.#ctor(System.Collections.IList)">
+            <summary>
+            
+            </summary>
+            <param name="items"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.Dispose">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.LogReceivedAdapter.Items">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogReceivedEventArgs.#ctor(log4net.Util.LogLog)">
+            <summary>
+            
+            </summary>
+            <param name="loglog"></param>
+        </member>
+        <member name="P:log4net.Util.LogReceivedEventArgs.LogLog">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.NativeError">
+            <summary>
+            Represents a native error code and message.
+            </summary>
+            <remarks>
+            <para>
+            Represents a Win32 platform native error.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NativeError.#ctor(System.Int32,System.String)">
+            <summary>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </summary>
+            <param name="number">The number of the native error.</param>
+            <param name="message">The message of the native error.</param>
+            <remarks>
+            <para>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetLastError">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class for the last Windows error.
+            </summary>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the last windows error.
+            </returns>
+            <remarks>
+            <para>
+            The message for the <see cref="M:System.Runtime.InteropServices.Marshal.GetLastWin32Error"/> error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetError(System.Int32)">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class.
+            </summary>
+            <param name="number">the error number for the native error</param>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the specified 
+            error number.
+            </returns>
+            <remarks>
+            <para>
+            The message for the specified error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetErrorMessage(System.Int32)">
+            <summary>
+            Retrieves the message corresponding with a Win32 message identifier.
+            </summary>
+            <param name="messageId">Message identifier for the requested message.</param>
+            <returns>
+            The message corresponding with the specified message identifier.
+            </returns>
+            <remarks>
+            <para>
+            The message will be searched for in system message-table resource(s)
+            using the native <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.ToString">
+            <summary>
+            Return error information string
+            </summary>
+            <returns>error information string</returns>
+            <remarks>
+            <para>
+            Return error information string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.FormatMessage(System.Int32,System.IntPtr@,System.Int32,System.Int32,System.String@,System.Int32,System.IntPtr)">
+            <summary>
+            Formats a message string.
+            </summary>
+            <param name="dwFlags">Formatting options, and how to interpret the <paramref name="lpSource" /> parameter.</param>
+            <param name="lpSource">Location of the message definition.</param>
+            <param name="dwMessageId">Message identifier for the requested message.</param>
+            <param name="dwLanguageId">Language identifier for the requested message.</param>
+            <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>
+            <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>
+            <param name="Arguments">Pointer to an array of values that are used as insert values in the formatted message.</param>
+            <remarks>
+            <para>
+            The function requires a message definition as input. The message definition can come from a 
+            buffer passed into the function. It can come from a message table resource in an 
+            already-loaded module. Or the caller can ask the function to search the system's message 
+            table resource(s) for the message definition. The function finds the message definition 
+            in a message table resource based on a message identifier and a language identifier. 
+            The function copies the formatted message text to an output buffer, processing any embedded 
+            insert sequences if requested.
+            </para>
+            <para>
+            To prevent the usage of unsafe code, this stub does not support inserting values in the formatted message.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is the number of TCHARs stored in the output 
+            buffer, excluding the terminating null character.
+            </para>
+            <para>
+            If the function fails, the return value is zero. To get extended error information, 
+            call <see cref="M:Marshal.GetLastWin32Error()" />.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Util.NativeError.Number">
+            <summary>
+            Gets the number of the native error.
+            </summary>
+            <value>
+            The number of the native error.
+            </value>
+            <remarks>
+            <para>
+            Gets the number of the native error.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NativeError.Message">
+            <summary>
+            Gets the message of the native error.
+            </summary>
+            <value>
+            The message of the native error.
+            </value>
+            <remarks>
+            <para>
+            </para>
+            Gets the message of the native error.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.NullDictionaryEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionaryEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionaryEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance.
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullDictionaryEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullDictionaryEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullDictionaryEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Key">
+            <summary>
+            Gets the current key from the enumerator.
+            </summary>
+            <remarks>
+            Throws an exception because the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>
+            never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Key"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Value">
+            <summary>
+            Gets the current value from the enumerator.
+            </summary>
+            <value>The current value from the enumerator.</value>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Value"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Entry">
+            <summary>
+            Gets the current entry from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current entry.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Entry"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Instance">
+            <summary>
+            Get the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullSecurityContext">
+            <summary>
+            A SecurityContext used when a SecurityContext is not required
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Util.NullSecurityContext"/> is a no-op implementation of the
+            <see cref="T:log4net.Core.SecurityContext"/> base class. It is used where a <see cref="T:log4net.Core.SecurityContext"/>
+            is required but one has not been provided.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.NullSecurityContext.Instance">
+            <summary>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            <para>
+            Private constructor for singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns><c>null</c></returns>
+            <remarks>
+            <para>
+            No impersonation is done and <c>null</c> is always returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OnlyOnceErrorHandler">
+            <summary>
+            Implements log4net's default error handling policy which consists 
+            of emitting a message for the first error in an appender and 
+            ignoring all subsequent errors.
+            </summary>
+            <remarks>
+            <para>
+            The error message is processed using the LogLog sub-system by default.
+            </para>
+            <para>
+            This policy aims at protecting an otherwise working application
+            from being flooded with error messages when logging fails.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="prefix">The prefix to use for each message.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class
+            with the specified prefix.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Reset">
+            <summary>
+            Reset the error handler back to its initial disabled state.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log the very first error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            Sends the error information to <see cref="T:log4net.Util.LogLog"/>'s Error method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">
+            <summary>
+            Log an error
+            </summary>
+            <param name="message">The error message.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_enabledDateUtc">
+            <summary>
+            The UTC date the error was recorded.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">
+            <summary>
+            Flag to indicate if it is the first error
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_message">
+            <summary>
+            The message recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_exception">
+            <summary>
+            The exception recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_errorCode">
+            <summary>
+            The error code recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">
+            <summary>
+            String to prefix each message with
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.declaringType">
+            <summary>
+            The fully qualified type of the OnlyOnceErrorHandler class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">
+            <summary>
+            Is error logging enabled
+            </summary>
+            <remarks>
+            <para>
+            Is error logging enabled. Logging is only enabled for the
+            first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDate">
+            <summary>
+            The date the first error that trigged this error handler occurred, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDateUtc">
+            <summary>
+            The UTC date the first error that trigged this error handler occured, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorMessage">
+            <summary>
+            The message from the first error that trigged this error handler.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.Exception">
+            <summary>
+            The exception from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            May be <see langword="null" />.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorCode">
+            <summary>
+            The error code from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            Defaults to <see cref="F:log4net.Core.ErrorCode.GenericFailure"/>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OptionConverter">
+            <summary>
+            A convenience class to convert property values to specific types.
+            </summary>
+            <remarks>
+            <para>
+            Utility functions for converting types and parsing values.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.OptionConverter"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToBoolean(System.String,System.Boolean)">
+            <summary>
+            Converts a string to a <see cref="T:System.Boolean"/> value.
+            </summary>
+            <param name="argValue">String to convert.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Boolean"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            If <paramref name="argValue"/> is "true", then <c>true</c> is returned. 
+            If <paramref name="argValue"/> is "false", then <c>false</c> is returned. 
+            Otherwise, <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToFileSize(System.String,System.Int64)">
+            <summary>
+            Parses a file size into a number.
+            </summary>
+            <param name="argValue">String to parse.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Int64"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            Parses a file size of the form: number[KB|MB|GB] into a
+            long value. It is scaled with the appropriate multiplier.
+            </para>
+            <para>
+            <paramref name="defaultValue"/> is returned when <paramref name="argValue"/>
+            cannot be converted to a <see cref="T:System.Int64"/> value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string to an object.
+            </summary>
+            <param name="target">The target type to convert to.</param>
+            <param name="txt">The string to convert to an object.</param>
+            <returns>
+            The object converted from a string or <c>null</c> when the 
+            conversion failed.
+            </returns>
+            <remarks>
+            <para>
+            Converts a string to an object. Uses the converter registry to try
+            to convert the string value into the specified target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.CanConvertTypeTo(System.Type,System.Type)">
+            <summary>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            </summary>
+            <param name="sourceType">The type to convert from.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns><c>true</c> if there is a conversion from the source type to the target type.</returns>
+            <remarks>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertTypeTo(System.Object,System.Type)">
+            <summary>
+            Converts an object to the target type.
+            </summary>
+            <param name="sourceInstance">The object to convert to the target type.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns>The converted object.</returns>
+            <remarks>
+            <para>
+            Converts an object to the target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">
+            <summary>
+            Instantiates an object given a class name.
+            </summary>
+            <param name="className">The fully qualified class name of the object to instantiate.</param>
+            <param name="superClass">The class to which the new object should belong.</param>
+            <param name="defaultValue">The object to return in case of non-fulfillment.</param>
+            <returns>
+            An instance of the <paramref name="className"/> or <paramref name="defaultValue"/>
+            if the object could not be instantiated.
+            </returns>
+            <remarks>
+            <para>
+            Checks that the <paramref name="className"/> is a subclass of
+            <paramref name="superClass"/>. If that test fails or the object could
+            not be instantiated, then <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.SubstituteVariables(System.String,System.Collections.IDictionary)">
+            <summary>
+            Performs variable substitution in string <paramref name="value"/> from the 
+            values of keys found in <paramref name="props"/>.
+            </summary>
+            <param name="value">The string on which variable substitution is performed.</param>
+            <param name="props">The dictionary to use to lookup variables.</param>
+            <returns>The result of the substitutions.</returns>
+            <remarks>
+            <para>
+            The variable substitution delimiters are <b>${</b> and <b>}</b>.
+            </para>
+            <para>
+            For example, if props contains <c>key=value</c>, then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of key is ${key}.");
+            </code>
+            </para>
+            <para>
+            will set the variable <c>s</c> to "Value of key is value.".
+            </para>
+            <para>
+            If no value could be found for the specified key, then substitution 
+            defaults to an empty string.
+            </para>
+            <para>
+            For example, if system properties contains no value for the key
+            "nonExistentKey", then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of nonExistentKey is [${nonExistentKey}]");
+            </code>
+            </para>
+            <para>
+            will set <s>s</s> to "Value of nonExistentKey is []".	 
+            </para>
+            <para>
+            An Exception is thrown if <paramref name="value"/> contains a start 
+            delimiter "${" which is not balanced by a stop delimiter "}". 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ParseEnum(System.Type,System.String,System.Boolean)">
+            <summary>
+            Converts the string representation of the name or numeric value of one or 
+            more enumerated constants to an equivalent enumerated object.
+            </summary>
+            <param name="enumType">The type to convert to.</param>
+            <param name="value">The enum string value.</param>
+            <param name="ignoreCase">If <c>true</c>, ignore case; otherwise, regard case.</param>
+            <returns>An object of type <paramref name="enumType" /> whose value is represented by <paramref name="value" />.</returns>
+        </member>
+        <member name="F:log4net.Util.OptionConverter.declaringType">
+            <summary>
+            The fully qualified type of the OptionConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser">
+            <summary>
+            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class
+            is delegated to the PatternParser class.
+            </summary>
+            <remarks>
+            <para>
+            The <c>PatternParser</c> processes a pattern string and
+            returns a chain of <see cref="T:log4net.Util.PatternConverter"/> objects.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.PatternParser.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="pattern">The pattern to parse.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternParser"/> class 
+            with the specified pattern string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.Parse">
+            <summary>
+            Parses the pattern into a chain of pattern converters.
+            </summary>
+            <returns>The head of a chain of pattern converters.</returns>
+            <remarks>
+            <para>
+            Parses the pattern into a chain of pattern converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.BuildCache">
+            <summary>
+            Build the unified cache of converters from the static and instance maps
+            </summary>
+            <returns>the list of all the converter names</returns>
+            <remarks>
+            <para>
+            Build the unified cache of converters from the static and instance maps
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ParseInternal(System.String,System.String[])">
+            <summary>
+            Internal method to parse the specified pattern to find specified matches
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <param name="matches">the converter names to match in the pattern</param>
+            <remarks>
+            <para>
+            The matches param must be sorted such that longer strings come before shorter ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessLiteral(System.String)">
+            <summary>
+            Process a parsed literal
+            </summary>
+            <param name="text">the literal text</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessConverter(System.String,System.String,log4net.Util.FormattingInfo)">
+            <summary>
+            Process a parsed converter pattern
+            </summary>
+            <param name="converterName">the name of the converter</param>
+            <param name="option">the optional option for the converter</param>
+            <param name="formattingInfo">the formatting info for the converter</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.AddConverter(log4net.Util.PatternConverter)">
+            <summary>
+            Resets the internal state of the parser and adds the specified pattern converter 
+            to the chain.
+            </summary>
+            <param name="pc">The pattern converter to add.</param>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_head">
+            <summary>
+            The first pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_tail">
+            <summary>
+             the last pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_pattern">
+            <summary>
+            The pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_patternConverters">
+            <summary>
+            Internal map of converter identifiers to converter types
+            </summary>
+            <remarks>
+            <para>
+            This map overrides the static s_globalRulesRegistry map.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternParser.declaringType">
+            <summary>
+            The fully qualified type of the PatternParser class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternParser.PatternConverters">
+            <summary>
+            Get the converter registry used by this parser
+            </summary>
+            <value>
+            The converter registry used by this parser
+            </value>
+            <remarks>
+            <para>
+            Get the converter registry used by this parser
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser.StringLengthComparer">
+            <summary>
+            Sort strings by length
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:System.Collections.IComparer"/> that orders strings by string length.
+            The longest strings are placed first
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternString">
+            <summary>
+            This class implements a patterned string.
+            </summary>
+            <remarks>
+            <para>
+            This string has embedded patterns that are resolved and expanded
+            when the string is formatted.
+            </para>
+            <para>
+            This class functions similarly to the <see cref="T:log4net.Layout.PatternLayout"/>
+            in that it accepts a pattern and renders it to a string. Unlike the 
+            <see cref="T:log4net.Layout.PatternLayout"/> however the <c>PatternString</c>
+            does not render the properties of a specific <see cref="T:log4net.Core.LoggingEvent"/> but
+            of the process in general.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+                        <para>
+                        Used to output the friendly name of the current AppDomain.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>appsetting</term>
+                    <description>
+                        <para>
+                        Used to output the value of a specific appSetting key in the application
+                        configuration file.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>date</term>
+                    <description>
+            			<para>
+            			Used to output the current date and time in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>env</term>
+                    <description>
+                        <para>
+            			Used to output the a specific environment variable. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%env{COMPUTERNAME}</b> would include the value
+            			of the <c>COMPUTERNAME</c> environment variable.
+                        </para>
+                        <para>
+                        The <c>env</c> pattern is not supported on the .NET Compact Framework.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>identity</term>
+                    <description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>newline</term>
+                    <description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern name offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+                    </description>
+                </item>
+                <item>
+                    <term>processid</term>
+                    <description>
+                        <para>
+            			Used to output the system process ID for the current process.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>property</term>
+                    <description>
+            			<para>
+            			Used to output a specific context property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are stored in logging contexts. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+                    </description>
+                </item>
+                <item>
+                    <term>random</term>
+                    <description>
+                        <para>
+                        Used to output a random string of characters. The string is made up of
+                        uppercase letters and numbers. By default the string is 4 characters long.
+                        The length of the string can be specified within braces directly following the
+            			pattern specifier, e.g. <b>%random{8}</b> would output an 8 character string.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>username</term>
+                    <description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>utcdate</term>
+                    <description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Util.PatternString"/>
+            instance using <see cref="M:AddConverter(ConverterInfo)"/> or
+            <see cref="M:AddConverter(string, Type)"/>.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.PatternLayout"/> for details on the 
+            <i>format modifiers</i> supported by the patterns.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternString.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternString only
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor(System.String)">
+            <summary>
+            Constructs a PatternString
+            </summary>
+            <param name="pattern">The pattern to use with this PatternString</param>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/> with the pattern specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.ActivateOptions">
+            <summary>
+            Initialize object options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternString.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternString.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternString.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.CreatePatternParser(System.String)">
+            <summary>
+            Create the <see cref="T:log4net.Util.PatternParser"/> used to parse the pattern
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/></returns>
+            <remarks>
+            <para>
+            Returns PatternParser used to parse the conversion string. Subclasses
+            may override this to return a subclass of PatternParser which recognize
+            custom conversion pattern name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format(System.IO.TextWriter)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the pattern to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format">
+            <summary>
+            Format the pattern as a string
+            </summary>
+            <returns>the pattern formatted as a string</returns>
+            <remarks>
+            <para>
+            Format the pattern to a string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a converter to this PatternString
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternString.ConversionPattern">
+            <summary>
+            Gets or sets the pattern formatting string
+            </summary>
+            <value>
+            The pattern formatting string
+            </value>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PropertiesDictionary">
+            <summary>
+            String keyed object map.
+            </summary>
+            <remarks>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.ReadOnlyPropertiesDictionary">
+            <summary>
+            String keyed object map that is read only.
+            </summary>
+            <remarks>
+            <para>
+            This collection is readonly and cannot be modified.
+            </para>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.ReadOnlyPropertiesDictionary.m_hashtable">
+            <summary>
+            The Hashtable used to store the properties data
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Copy Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Deserialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetKeys">
+            <summary>
+            Gets the key names.
+            </summary>
+            <returns>An array of all the keys.</returns>
+            <remarks>
+            <para>
+            Gets the key names.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Contains(System.String)">
+            <summary>
+            Test if the dictionary contains a specified key
+            </summary>
+            <param name="key">the key to look for</param>
+            <returns>true if the dictionary contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if the dictionary contains a specified key
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <param name="value"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.InnerHashtable">
+            <summary>
+            The hashtable used to store the properties
+            </summary>
+            <value>
+            The internal collection used to store the properties
+            </value>
+            <remarks>
+            <para>
+            The hashtable used to store the properties
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Count">
+            <summary>
+            The number of properties in this collection
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class 
+            with serialized data.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Because this class is sealed the serialization constructor is private.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Remove(System.String)">
+            <summary>
+            Remove the entry with the specified key from this dictionary
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+            <returns>an enumerator</returns>
+            <remarks>
+            <para>
+            Returns a <see cref="T:System.Collections.IDictionaryEnumerator"/> over the contest of this collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key">the key to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key">the key to lookup in the collection</param>
+            <returns><c>true</c> if the collection contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if this collection contains a specified key.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+            <remarks>
+            <para>
+            Remove all properties from the properties collection
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key">the key</param>
+            <param name="value">the value to store for the key</param>
+            <remarks>
+            <para>
+            Store a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+            <value>
+            <c>false</c>
+            </value>
+            <remarks>
+            <para>
+            This collection is modifiable. This property always
+            returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+            <value>
+            The value for the key specified.
+            </value>
+            <remarks>
+            <para>
+            Get or set a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="T:log4net.Util.PropertyEntry">
+            <summary>
+            A class to hold the key and data for a property set in the config file
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the key and data for a property set in the config file
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertyEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Key">
+            <summary>
+            Property Key
+            </summary>
+            <value>
+            Property Key
+            </value>
+            <remarks>
+            <para>
+            Property Key.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Value">
+            <summary>
+            Property Value
+            </summary>
+            <value>
+            Property Value
+            </value>
+            <remarks>
+            <para>
+            Property Value.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ProtectCloseTextWriter">
+            <summary>
+            A <see cref="T:System.IO.TextWriter"/> that ignores the <see cref="M:log4net.Util.ProtectCloseTextWriter.Close"/> message
+            </summary>
+            <remarks>
+            <para>
+            This writer is used in special cases where it is necessary 
+            to protect a writer from being closed by a client.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <remarks>
+            <para>
+            Create a new ProtectCloseTextWriter using a writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Attach(System.IO.TextWriter)">
+            <summary>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to attach to</param>
+            <remarks>
+            <para>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Close">
+            <summary>
+            Does not close the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Does not close the underlying output writer.
+            This method does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReaderWriterLock">
+            <summary>
+            Defines a lock that supports single writers and multiple readers
+            </summary>
+            <remarks>
+            <para>
+            <c>ReaderWriterLock</c> is used to synchronize access to a resource. 
+            At any given time, it allows either concurrent read access for 
+            multiple threads, or write access for a single thread. In a 
+            situation where a resource is changed infrequently, a 
+            <c>ReaderWriterLock</c> provides better throughput than a simple 
+            one-at-a-time lock, such as <see cref="T:System.Threading.Monitor"/>.
+            </para>
+            <para>
+            If a platform does not support a <c>System.Threading.ReaderWriterLock</c> 
+            implementation then all readers and writers are serialized. Therefore 
+            the caller must not rely on multiple simultaneous readers.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReaderWriterLock"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireReaderLock">
+            <summary>
+            Acquires a reader lock
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.AcquireReaderLock"/> blocks if a different thread has the writer 
+            lock, or if at least one thread is waiting for the writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock">
+            <summary>
+            Decrements the lock count
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock"/> decrements the lock count. When the count 
+            reaches zero, the lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireWriterLock">
+            <summary>
+            Acquires the writer lock
+            </summary>
+            <remarks>
+            <para>
+            This method blocks if another thread has a reader lock or writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseWriterLock">
+            <summary>
+            Decrements the lock count on the writer lock
+            </summary>
+            <remarks>
+            <para>
+            ReleaseWriterLock decrements the writer lock count. 
+            When the count reaches zero, the writer lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReusableStringWriter">
+            <summary>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.
+            This uses a single buffer for string operations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </summary>
+            <param name="formatProvider">the format provider to use</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">
+            <summary>
+            Override Dispose to prevent closing of writer
+            </summary>
+            <param name="disposing">flag</param>
+            <remarks>
+            <para>
+            Override Dispose to prevent closing of writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">
+            <summary>
+            Reset this string writer so that it can be reused.
+            </summary>
+            <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>
+            <param name="defaultSize">the default size to make the buffer</param>
+            <remarks>
+            <para>
+            Reset this string writer so that it can be reused.
+            The internal buffers are cleared and reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemInfo">
+            <summary>
+            Utility class for system specific information.
+            </summary>
+            <remarks>
+            <para>
+            Utility class of static methods for system specific information.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Alexey Solofnenko</author>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#ctor">
+            <summary>
+            Private constructor to prevent instances.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#cctor">
+            <summary>
+            Initialize default values for private static fields.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyLocationInfo(System.Reflection.Assembly)">
+            <summary>
+            Gets the assembly location path for the specified assembly.
+            </summary>
+            <param name="myAssembly">The assembly to get the location for.</param>
+            <returns>The location of the assembly.</returns>
+            <remarks>
+            <para>
+            This method does not guarantee to return the correct path
+            to the assembly. If only tries to give an indication as to
+            where the assembly was loaded from.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyQualifiedName(System.Type)">
+            <summary>
+            Gets the fully qualified name of the <see cref="T:System.Type"/>, including 
+            the name of the assembly from which the <see cref="T:System.Type"/> was 
+            loaded.
+            </summary>
+            <param name="type">The <see cref="T:System.Type"/> to get the fully qualified name for.</param>
+            <returns>The fully qualified name for the <see cref="T:System.Type"/>.</returns>
+            <remarks>
+            <para>
+            This is equivalent to the <c>Type.AssemblyQualifiedName</c> property,
+            but this method works on the .NET Compact Framework 1.0 as well as
+            the full .NET runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyShortName(System.Reflection.Assembly)">
+            <summary>
+            Gets the short name of the <see cref="T:System.Reflection.Assembly"/>.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the name for.</param>
+            <returns>The short name of the <see cref="T:System.Reflection.Assembly"/>.</returns>
+            <remarks>
+            <para>
+            The short name of the assembly is the <see cref="P:System.Reflection.Assembly.FullName"/> 
+            without the version, culture, or public key. i.e. it is just the 
+            assembly's file name without the extension.
+            </para>
+            <para>
+            Use this rather than <c>Assembly.GetName().Name</c> because that
+            is not available on the Compact Framework.
+            </para>
+            <para>
+            Because of a FileIOPermission security demand we cannot do
+            the obvious Assembly.GetName().Name. We are allowed to get
+            the <see cref="P:System.Reflection.Assembly.FullName"/> of the assembly so we 
+            start from there and strip out just the assembly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyFileName(System.Reflection.Assembly)">
+            <summary>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the file name for.</param>
+            <returns>The file name of the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Type,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeType">A sibling type to use to load the type.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified, it will be loaded from the assembly
+            containing the specified relative type. If the type is not found in the assembly 
+            then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>		
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the
+            assembly that is directly calling this method. If the type is not found 
+            in the assembly then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Reflection.Assembly,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeAssembly">An assembly to load the type from.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the specified
+            assembly. If the type is not found in the assembly then all the loaded assemblies 
+            will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.NewGuid">
+            <summary>
+            Generate a new guid
+            </summary>
+            <returns>A new Guid</returns>
+            <remarks>
+            <para>
+            Generate a new guid
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateArgumentOutOfRangeException(System.String,System.Object,System.String)">
+            <summary>
+            Create an <see cref="T:System.ArgumentOutOfRangeException"/>
+            </summary>
+            <param name="parameterName">The name of the parameter that caused the exception</param>
+            <param name="actualValue">The value of the argument that causes this exception</param>
+            <param name="message">The message that describes the error</param>
+            <returns>the ArgumentOutOfRangeException object</returns>
+            <remarks>
+            <para>
+            Create a new instance of the <see cref="T:System.ArgumentOutOfRangeException"/> class 
+            with a specified error message, the parameter name, and the value 
+            of the argument.
+            </para>
+            <para>
+            The Compact Framework does not support the 3 parameter constructor for the
+            <see cref="T:System.ArgumentOutOfRangeException"/> type. This method provides an
+            implementation that works for all platforms.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int32@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int32"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int64@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int64"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int16@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int16"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetAppSetting(System.String)">
+            <summary>
+            Lookup an application setting
+            </summary>
+            <param name="key">the application settings key to lookup</param>
+            <returns>the value for the key, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Configuration APIs are not supported under the Compact Framework
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified local file path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            <para>
+            The path specified must be a local file path, a URI is not supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateCaseInsensitiveHashtable">
+            <summary>
+            Creates a new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity. 
+            </summary>
+            <returns>A new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity</returns>
+            <remarks>
+            <para>
+            The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.EqualsIgnoringCase(System.String,System.String)">
+            <summary>
+            Tests two strings for equality, the ignoring case.
+            </summary>
+            <remarks>
+            If the platform permits, culture information is ignored completely (ordinal comparison).
+            The aim of this method is to provide a fast comparison that deals with <c>null</c> and ignores different casing.
+            It is not supposed to deal with various, culture-specific habits.
+            Use it to compare against pure ASCII constants, like keywords etc.
+            </remarks>
+            <param name="a">The one string.</param>
+            <param name="b">The other string.</param>
+            <returns><c>true</c> if the strings are equal, <c>false</c> otherwise.</returns>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.EmptyTypes">
+            <summary>
+            Gets an empty array of types.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Type.EmptyTypes</c> field is not available on
+            the .NET Compact Framework 1.0.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.declaringType">
+            <summary>
+            The fully qualified type of the SystemInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_hostName">
+            <summary>
+            Cache the host name for the current machine
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_appFriendlyName">
+            <summary>
+            Cache the application friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_nullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_notAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_processStartTimeUtc">
+            <summary>
+            Start time for the current process.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NewLine">
+            <summary>
+            Gets the system dependent line terminator.
+            </summary>
+            <value>
+            The system dependent line terminator.
+            </value>
+            <remarks>
+            <para>
+            Gets the system dependent line terminator.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationBaseDirectory">
+            <summary>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The base directory path for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ConfigurationFileLocation">
+            <summary>
+            Gets the path to the configuration file for the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the configuration file for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            The .NET Compact Framework 1.0 does not have a concept of a configuration
+            file. For this runtime, we use the entry assembly location as the root for
+            the configuration file name.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.EntryAssemblyLocation">
+            <summary>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the entry assembly.</value>
+            <remarks>
+            <para>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.CurrentThreadId">
+            <summary>
+            Gets the ID of the current thread.
+            </summary>
+            <value>The ID of the current thread.</value>
+            <remarks>
+            <para>
+            On the .NET framework, the <c>AppDomain.GetCurrentThreadId</c> method
+            is used to obtain the thread ID for the current thread. This is the 
+            operating system ID for the thread.
+            </para>
+            <para>
+            On the .NET Compact Framework 1.0 it is not possible to get the 
+            operating system thread ID for the current thread. The native method 
+            <c>GetCurrentThreadId</c> is implemented inline in a header file
+            and cannot be called.
+            </para>
+            <para>
+            On the .NET Framework 2.0 the <c>Thread.ManagedThreadId</c> is used as this
+            gives a stable id unrelated to the operating system thread ID which may 
+            change if the runtime is using fibers.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.HostName">
+            <summary>
+            Get the host name or machine name for the current machine
+            </summary>
+            <value>
+            The hostname or machine name
+            </value>
+            <remarks>
+            <para>
+            Get the host name or machine name for the current machine
+            </para>
+            <para>
+            The host name (<see cref="M:System.Net.Dns.GetHostName"/>) or
+            the machine name (<c>Environment.MachineName</c>) for
+            the current machine, or if neither of these are available
+            then <c>NOT AVAILABLE</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationFriendlyName">
+            <summary>
+            Get this application's friendly name
+            </summary>
+            <value>
+            The friendly name of this application as a string
+            </value>
+            <remarks>
+            <para>
+            If available the name of the application is retrieved from
+            the <c>AppDomain</c> using <c>AppDomain.CurrentDomain.FriendlyName</c>.
+            </para>
+            <para>
+            Otherwise the file name of the entry assembly is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTime">
+            <summary>
+            Get the start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTimeUtc">
+            <summary>
+            Get the UTC start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the UTC time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+            <remarks>
+            <para>
+            Use this value to indicate a <c>null</c> has been encountered while
+            outputting a string representation of an item.
+            </para>
+            <para>
+            The default value is <c>(null)</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NullText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NotAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+            <remarks>
+            <para>
+            Use this value when an unsupported feature is requested.
+            </para>
+            <para>
+            The default value is <c>NOT AVAILABLE</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NotAvailableText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemStringFormat">
+            <summary>
+            Utility class that represents a format string.
+            </summary>
+            <remarks>
+            <para>
+            Utility class that represents a format string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.#ctor(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Initialise the <see cref="T:log4net.Util.SystemStringFormat"/>
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.ToString">
+            <summary>
+            Format the string and arguments
+            </summary>
+            <returns>the formatted string</returns>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Replaces the format item in a specified <see cref="T:System.String"/> with the text equivalent 
+            of the value of a corresponding <see cref="T:System.Object"/> instance in a specified array.
+            A specified parameter supplies culture-specific formatting information.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+            <returns>
+            A copy of format in which the format items have been replaced by the <see cref="T:System.String"/> 
+            equivalent of the corresponding instances of <see cref="T:System.Object"/> in args.
+            </returns>
+            <remarks>
+            <para>
+            This method does not throw exceptions. If an exception thrown while formatting the result the
+            exception and arguments are returned in the result string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormatError(System.Exception,System.String,System.Object[])">
+            <summary>
+            Process an error during StringFormat
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderArray(System.Array,System.Text.StringBuilder)">
+            <summary>
+            Dump the contents of an array into a string builder
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderObject(System.Object,System.Text.StringBuilder)">
+            <summary>
+            Dump an object to a string
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemStringFormat.declaringType">
+            <summary>
+            The fully qualified type of the SystemStringFormat class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextProperties._dictionary">
+            <summary>
+            Each thread will automatically have its instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove a property
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetKeys">
+            <summary>
+            Get the keys stored in the properties.
+            </summary>
+            <para>
+            Gets the keys stored in the properties.
+            </para>
+            <returns>a set of the defined keys</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Clear">
+            <summary>
+            Clear all properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the <c>PropertiesDictionary</c> for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this tread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.ThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.ThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.ThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameStack">
+            <summary>
+            The ThreadContextStack internal stack
+            </summary>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.#ctor(System.Collections.Stack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.Transform">
+            <summary>
+            Utility class for transforming strings.
+            </summary>
+            <remarks>
+            <para>
+            Utility class for transforming strings.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.Transform.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.Transform"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.WriteEscapedXmlString(System.Xml.XmlWriter,System.String,System.String)">
+            <summary>
+            Write a string to an <see cref="T:System.Xml.XmlWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="textData">the string to write</param>
+            <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param>
+            <remarks>
+            <para>
+            The test is escaped either using XML escape entities
+            or using CDATA sections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.MaskXmlInvalidCharacters(System.String,System.String)">
+            <summary>
+            Replace invalid XML characters in text string
+            </summary>
+            <param name="textData">the XML text input string</param>
+            <param name="mask">the string to use in place of invalid characters</param>
+            <returns>A string that does not contain invalid XML characters.</returns>
+            <remarks>
+            <para>
+            Certain Unicode code points are not allowed in the XML InfoSet, for
+            details see: <a href="http://www.w3.org/TR/REC-xml/#charsets">http://www.w3.org/TR/REC-xml/#charsets</a>.
+            </para>
+            <para>
+            This method replaces any illegal characters in the input string
+            with the mask string specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.CountSubstrings(System.String,System.String)">
+            <summary>
+            Count the number of times that the substring occurs in the text
+            </summary>
+            <param name="text">the text to search</param>
+            <param name="substring">the substring to find</param>
+            <returns>the number of times the substring occurs in the text</returns>
+            <remarks>
+            <para>
+            The substring is assumed to be non repeating within itself.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.Transform.INVALIDCHARS">
+            <summary>
+            Characters illegal in XML 1.0
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext">
+            <summary>
+            Impersonate a Windows Account
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.SecurityContext"/> impersonates a Windows account.
+            </para>
+            <para>
+            How the impersonation is done depends on the value of <see cref="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)"/>.
+            This allows the context to either impersonate a set of user credentials specified 
+            using username, domain name and password or to revert to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.ActivateOptions">
+            <summary>
+            Initialize the SecurityContext based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The security context will try to Logon the specified user account and
+            capture a primary token for impersonation.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, 
+            <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> or <see cref="P:log4net.Util.WindowsSecurityContext.Password"/> properties were not specified.</exception>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.
+            </summary>
+            <param name="state">caller provided state</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> instance that will revoke the impersonation of this SecurityContext
+            </returns>
+            <remarks>
+            <para>
+            Depending on the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property either
+            impersonate a user using credentials supplied or revert 
+            to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.LogonUser(System.String,System.String,System.String)">
+            <summary>
+            Create a <see cref="T:System.Security.Principal.WindowsIdentity"/> given the userName, domainName and password.
+            </summary>
+            <param name="userName">the user name</param>
+            <param name="domainName">the domain name</param>
+            <param name="password">the password</param>
+            <returns>the <see cref="T:System.Security.Principal.WindowsIdentity"/> for the account specified</returns>
+            <remarks>
+            <para>
+            Uses the Windows API call LogonUser to get a principal token for the account. This
+            token is used to initialize the WindowsIdentity.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Credentials">
+            <summary>
+            Gets or sets the impersonation mode for this security context
+            </summary>
+            <value>
+            The impersonation mode for this security context
+            </value>
+            <remarks>
+            <para>
+            Impersonate either a user with user credentials or
+            revert this thread to the credentials of the process.
+            The value is one of the <see cref="T:log4net.Util.WindowsSecurityContext.ImpersonationMode"/>
+            enum.
+            </para>
+            <para>
+            The default value is <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            the user's credentials are established using the
+            <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.Password"/>
+            values.
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process"/>
+            no other properties need to be set. If the calling thread is 
+            impersonating then it will be reverted back to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.UserName">
+            <summary>
+            Gets or sets the Windows username for this security context
+            </summary>
+            <value>
+            The Windows username for this security context
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.DomainName">
+            <summary>
+            Gets or sets the Windows domain name for this security context
+            </summary>
+            <value>
+            The Windows domain name for this security context
+            </value>
+            <remarks>
+            <para>
+            The default value for <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> is the local machine name
+            taken from the <see cref="P:System.Environment.MachineName"/> property.
+            </para>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Password">
+            <summary>
+            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.
+            </summary>
+            <value>
+            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.
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.ImpersonationMode">
+            <summary>
+            The impersonation modes for the <see cref="T:log4net.Util.WindowsSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            See the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property for
+            details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User">
+            <summary>
+            Impersonate a user using the credentials supplied
+            </summary>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process">
+            <summary>
+            Revert this the thread to the credentials of the process
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext">
+            <summary>
+            Adds <see cref="T:System.IDisposable"/> to <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Helper class to expose the <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            through the <see cref="T:System.IDisposable"/> interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.#ctor(System.Security.Principal.WindowsImpersonationContext)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="impersonationContext">the impersonation context being wrapped</param>
+            <remarks>
+            <para>
+            Constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.Dispose">
+            <summary>
+            Revert the impersonation
+            </summary>
+            <remarks>
+            <para>
+            Revert the impersonation
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.GlobalContext">
+            <summary>
+            The log4net Global Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>GlobalContext</c> provides a location for global debugging 
+            information to be stored.
+            </para>
+            <para>
+            The global context has a properties map and these properties can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputing these properties.
+            </para>
+            <para>
+            By default the <c>log4net:HostName</c> property is set to the name of 
+            the current machine.
+            </para>
+            </remarks>
+            <example>
+            <code lang="C#">
+            GlobalContext.Properties["hostname"] = Environment.MachineName;
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.GlobalContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="F:log4net.GlobalContext.s_properties">
+            <summary>
+            The global context properties instance
+            </summary>
+        </member>
+        <member name="P:log4net.GlobalContext.Properties">
+            <summary>
+            The global properties map.
+            </summary>
+            <value>
+            The global properties map.
+            </value>
+            <remarks>
+            <para>
+            The global properties map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.AssemblyInfo">
+            <summary>
+            Provides information about the environment the assembly has
+            been built for.
+            </summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.Version">
+            <summary>Version of the assembly</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFrameworkVersion">
+            <summary>Version of the framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFramework">
+            <summary>Type of framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.ClientProfile">
+            <summary>Does it target a client profile?</summary>
+        </member>
+        <member name="P:log4net.AssemblyInfo.Info">
+            <summary>
+            Identifies the version and target for this assembly.
+            </summary>
+        </member>
+        <member name="T:log4net.LogicalThreadContext">
+            <summary>
+            The log4net Logical Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> provides a location for <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> specific debugging 
+            information to be stored.
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> or <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The Logical Thread Context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Logical Thread Context provides a diagnostic context for the current call context. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Logical Thread Context is managed on a per <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> basis.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            LogicalThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a LogicalThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.LogicalThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> 
+            or <see cref="T:log4net.GlobalContext"/> properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The logical thread stacks.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.LogManager">
+            <summary>
+            This class is used by client applications to request logger instances.
+            </summary>
+            <remarks>
+            <para>
+            This class has static methods that are used by a client to request
+            a logger instance. The <see cref="M:GetLogger(string)"/> method is 
+            used to retrieve a logger.
+            </para>
+            <para>
+            See the <see cref="T:log4net.ILog"/> interface for more details.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <seealso cref="T:log4net.ILog"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.LogManager.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.LogManager"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String)">
+            <overloads>Returns the named logger if it exists.</overloads>
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the default repository) then it
+            returns a reference to the logger, otherwise it returns <c>null</c>.
+            </para>
+            </remarks>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>The logger found, or <c>null</c> if no logger could be found.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers">
+            <overloads>Get the currently defined loggers.</overloads>
+            <summary>
+            Returns all the currently defined loggers in the default repository.
+            </summary>
+            <remarks>
+            <para>The root logger is <b>not</b> included in the returned array.</para>
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String)">
+            <overloads>Get or create a logger.</overloads>
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the logger doesn't exist in the specified 
+            repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the repository for the specified assembly) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger, or <c>null</c> if the logger doesn't exist in the specified
+            assembly's repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Get the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository">
+            <overloads>Shutdown a logger repository.</overloads>
+            <summary>
+            Shuts down the default repository.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            default repository.
+            </para>
+            <para>Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repository">The repository to shutdown.</param>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration">
+            <overloads>Reset the configuration of a repository</overloads>
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repository">The repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository">
+            <overloads>Get the logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository">
+            <overloads>Get a logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Type)">
+            <overloads>Create a domain</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Type)">
+            <overloads>Create a logger repository.</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetAllRepositories">
+            <summary>
+            Gets the list of currently defined repositories.
+            </summary>
+            <remarks>
+            <para>
+            Get an array of all the <see cref="T:log4net.Repository.ILoggerRepository"/> objects that have been created.
+            </para>
+            </remarks>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Flush(System.Int32)">
+            <summary>
+            Flushes logging events buffered in all configured appenders in the default repository.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLogger(log4net.Core.ILogger)">
+            <summary>
+            Looks up the wrapper object for the logger specified.
+            </summary>
+            <param name="logger">The logger to get the wrapper for.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLoggers(log4net.Core.ILogger[])">
+            <summary>
+            Looks up the wrapper objects for the loggers specified.
+            </summary>
+            <param name="loggers">The loggers to get the wrappers for.</param>
+            <returns>The wrapper objects for the loggers specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapperCreationHandler(log4net.Core.ILogger)">
+            <summary>
+            Create the <see cref="T:log4net.Core.ILoggerWrapper"/> objects used by
+            this manager.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="F:log4net.LogManager.s_wrapperMap">
+            <summary>
+            The wrapper map to use to hold the <see cref="T:log4net.Core.LogImpl"/> objects.
+            </summary>
+        </member>
+        <member name="T:log4net.MDC">
+            <summary>
+            Implementation of Mapped Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is
+            based on a map instead of a stack. It provides <i>mapped
+            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or
+            MDC in short, is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The MDC is managed on a per thread basis.
+            </para>
+            </remarks>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.MDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.MDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Get(System.String)">
+            <summary>
+            Gets the context value identified by the <paramref name="key"/> parameter.
+            </summary>
+            <param name="key">The key to lookup in the MDC.</param>
+            <returns>The string value held for the key, or a <c>null</c> reference if no corresponding value is found.</returns>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            If the <paramref name="key"/> parameter does not look up to a
+            previously defined context then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Set(System.String,System.String)">
+            <summary>
+            Add an entry to the MDC
+            </summary>
+            <param name="key">The key to store the value under.</param>
+            <param name="value">The value to store.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Puts a context value (the <paramref name="value"/> parameter) as identified
+            with the <paramref name="key"/> parameter into the current thread's
+            context map.
+            </para>
+            <para>
+            If a value is already defined for the <paramref name="key"/>
+            specified then the value will be replaced. If the <paramref name="value"/> 
+            is specified as <c>null</c> then the key value mapping will be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Remove(System.String)">
+            <summary>
+            Removes the key value mapping for the key specified.
+            </summary>
+            <param name="key">The key to remove.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove the specified entry from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Clear">
+            <summary>
+            Clear all entries in the MDC
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove all the entries from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.NDC">
+            <summary>
+            Implementation of Nested Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            A Nested Diagnostic Context, or NDC in short, is an instrument
+            to distinguish interleaved log output from different sources. Log
+            output is typically interleaved when a server handles multiple
+            clients near-simultaneously.
+            </para>
+            <para>
+            Interleaved log output can still be meaningful if each log entry
+            from different contexts had a distinctive stamp. This is where NDCs
+            come into play.
+            </para>
+            <para>
+            Note that NDCs are managed on a per thread basis. The NDC class
+            is made up of static methods that operate on the context of the
+            calling thread.
+            </para>
+            </remarks>
+            <example>How to push a message into the context
+            <code lang="C#">
+            using(NDC.Push("my context message"))
+            {
+            	... all log calls will have 'my context message' included ...
+            
+            } // at the end of the using block the message is automatically removed 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.NDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.NDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Clear">
+            <summary>
+            Clears all the contextual information held on the current thread.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Clears the stack of NDC data held on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.CloneStack">
+            <summary>
+            Creates a clone of the stack of context information.
+            </summary>
+            <returns>A clone of the context info for this thread.</returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The results of this method can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> 
+            method to allow child threads to inherit the context of their 
+            parent thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">
+            <summary>
+            Inherits the contextual information from another thread.
+            </summary>
+            <param name="stack">The context stack to inherit.</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This thread will use the context information from the stack
+            supplied. This can be used to initialize child threads with
+            the same contextual information as their parent threads. These
+            contexts will <b>NOT</b> be shared. Any further contexts that
+            are pushed onto the stack will not be visible to the other.
+            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to
+            this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Pop">
+            <summary>
+            Removes the top context from the stack.
+            </summary>
+            <returns>
+            The message in the context that was removed from the top 
+            of the stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Remove the top context from the stack, and return
+            it to the caller. If the stack is empty then an
+            empty string (not <c>null</c>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Push(System.String)">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.NDC.Push("NDC_Message"))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.PushFormat(System.String,System.Object[])">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="messageFormat">The new context message string format.</param>
+            <param name="args">Arguments to be passed into messageFormat.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            var someValue = "ExampleContext"
+            using(log4net.NDC.PushFormat("NDC_Message {0}", someValue))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.Remove">
+            <summary>
+            Removes the context information for this thread. It is
+            not required to call this method.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This method is not implemented.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">
+            <summary>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            </summary>
+            <param name="maxDepth">The maximum depth of the stack</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            This may truncate the head of the stack. This only affects the 
+            stack in the current thread. Also it does not prevent it from
+            growing, it only sets the maximum depth at the time of the
+            call. This can be used to return to a known context depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.NDC.Depth">
+            <summary>
+            Gets the current context depth.
+            </summary>
+            <value>The current context depth.</value>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The number of context values pushed onto the context stack.
+            </para>
+            <para>
+            Used to record the current depth of the context. This can then 
+            be restored using the <see cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/> method.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/>
+        </member>
+        <member name="T:log4net.ThreadContext">
+            <summary>
+            The log4net Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> provides a location for thread specific debugging 
+            information to be stored.
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            The thread context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Thread Context provides a diagnostic context for the current thread. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Thread Context is managed on a per thread basis.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            ThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a ThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(ThreadContext.Stacks["NDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a ThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.ThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.ThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.ThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.ThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The thread local stacks.
+            </para>
+            </remarks>
+        </member>
+    </members>
+</doc>
diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-client/log4net.dll b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-client/log4net.dll
new file mode 100644
index 0000000000000000000000000000000000000000..e8a0d0eced735ec50b786a8b4d2cf7a707037cc5
GIT binary patch
literal 282624
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

literal 0
HcmV?d00001

diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-client/log4net.xml b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-client/log4net.xml
new file mode 100644
index 000000000..d7d5be6e7
--- /dev/null
+++ b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-client/log4net.xml
@@ -0,0 +1,32259 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>log4net</name>
+    </assembly>
+    <members>
+        <member name="T:log4net.Appender.AdoNetAppender">
+            <summary>
+            Appender that logs to a database.
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
+            database. The appender can be configured to specify the connection 
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
+            property. For more information on database connection strings for
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
+            </para>
+            <para>
+            Records are written into the database either using a prepared
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
+            procedure.
+            </para>
+            <para>
+            The prepared statement text or the name of the stored procedure
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
+            </para>
+            <para>
+            The prepared statement or stored procedure can take a number
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
+            type may be subclassed if required to provide database specific
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
+            the parameter name, database type, size, and how the value should
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
+            </para>
+            </remarks>
+            <example>
+            An example of a SQL Server table that could be logged to:
+            <code lang="SQL">
+            CREATE TABLE [dbo].[Log] ( 
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,
+              [Date] [datetime] NOT NULL ,
+              [Thread] [varchar] (255) NOT NULL ,
+              [Level] [varchar] (20) NOT NULL ,
+              [Logger] [varchar] (255) NOT NULL ,
+              [Message] [varchar] (4000) NOT NULL 
+            ) ON [PRIMARY]
+            </code>
+            </example>
+            <example>
+            An example configuration to log to the above table:
+            <code lang="XML" escaped="true">
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
+              <parameter>
+                <parameterName value="@log_date"/>
+                <dbType value="DateTime"/>
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@thread"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@log_level"/>
+                <dbType value="String"/>
+                <size value="50"/>
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@logger"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@message"/>
+                <dbType value="String"/>
+                <size value="4000"/>
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>
+              </parameter>
+            </appender>
+            </code>
+            </example>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Lance Nehring</author>
+        </member>
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
+            buffers events in a fixed size buffer.
+            </summary>
+            <remarks>
+            <para>
+            This base class should be used by appenders that need to buffer a 
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            buffers events and then submits the entire contents of the buffer to 
+            the underlying database in one go.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:SendBuffer(LoggingEvent[])"/>
+            method to deliver the buffered events.
+            </para>
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
+            buffer of events. The size of the buffer is set using 
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
+            </para>
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
+            triggers, then the current buffer is sent immediately 
+            (see <see cref="M:SendBuffer(LoggingEvent[])"/>). Otherwise the event 
+            is stored in the buffer. For example, an evaluator can be used to 
+            deliver the events immediately when an ERROR event arrives.
+            </para>
+            <para>
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
+            By default the appender is NOT lossy. When the buffer is full all 
+            the buffered events are sent with <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
+            buffer will not be sent when it is full, and new events arriving 
+            in the appender will overwrite the oldest event in the buffer. 
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
+            triggers. This can be useful behavior when you need to know about 
+            ERROR events but not about events with a lower level, configure an 
+            evaluator that will trigger when an ERROR event arrives, the whole 
+            buffer will be sent which gives a history of events leading up to
+            the ERROR event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.AppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
+            </summary>
+            <remarks>
+            <para>
+            This class provides the code for common functionality, such 
+            as support for threshold filtering and support for general filters.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.IAppender">
+            <summary>
+            Implement this interface for your own strategies for printing log statements.
+            </summary>
+            <remarks>
+            <para>
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
+            class which provides a default implementation of this interface.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.IAppender.Close">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logging event in Appender specific way.
+            </summary>
+            <param name="loggingEvent">The event to log</param>
+            <remarks>
+            <para>
+            This method is called to log a message into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.IAppender.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>The name uniquely identifies the appender.</para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IBulkAppender">
+            <summary>
+            Interface for appenders that support bulk logging.
+            </summary>
+            <remarks>
+            <para>
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
+            should only implement this interface if they can bulk log efficiently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Log the array of logging events in Appender specific way.
+            </summary>
+            <param name="loggingEvents">The events to log</param>
+            <remarks>
+            <para>
+            This method is called to log an array of events into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IOptionHandler">
+            <summary>
+            Interface used to delay activate a configured object.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
+            must be called by the container after its all the configured properties have been set 
+            and before the component can be used.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
+            <summary>
+            Activate the options that were previously set with calls to properties.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then this method must be called
+            after its properties have been set before the component can be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IFlushable">
+            <summary>
+            Interface that can be implemented by Appenders that buffer logging data and expose a <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.IFlushable.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            Appenders that implement the <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method must do so in a thread-safe manner: it can be called concurrently with
+            the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            <para>
+            Typically this is done by locking on the Appender instance, e.g.:
+            <code>
+            <![CDATA[
+            public bool Flush(int millisecondsTimeout)
+            {
+                lock(this)
+                {
+                    // Flush buffered logging data
+                    ...
+                }
+            }
+            ]]>
+            </code>
+            </para>
+            <para>
+            The <paramref name="millisecondsTimeout"/> parameter is only relevant for appenders that process logging events asynchronously,
+            such as <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            </remarks>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>Empty default constructor</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
+            <summary>
+            Finalizes this appender by calling the implementation's 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
+            </summary>
+            <remarks>
+            <para>
+            If this appender has not been closed then the <c>Finalize</c> method
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">
+            <summary>
+            Closes the appender and release resources.
+            </summary>
+            <remarks>
+            <para>
+            Release any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            <para>
+            This method cannot be overridden by subclasses. This method 
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
+            method which must be overridden in the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent)"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>
+            will be passed to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent[])"/> method.
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent[])"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvents"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvents"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>
+            will be passed to the <see cref="M:Append(LoggingEvent[])"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if the logging event should we output by this appender
+            </summary>
+            <param name="loggingEvent">the event to test</param>
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
+            <remarks>
+            <para>
+            This method checks the logging event against the threshold level set
+            on this appender and also against the filters specified on this
+            appender.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
+            <summary>
+            Adds a filter to the end of the filter chain.
+            </summary>
+            <param name="filter">the filter to add to this appender</param>
+            <remarks>
+            <para>
+            The Filters are organized in a linked list.
+            </para>
+            <para>
+            Setting this property causes the new filter to be pushed onto the 
+            back of the filter chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
+            <summary>
+            Clears the filter list for this appender.
+            </summary>
+            <remarks>
+            <para>
+            Clears the filter list for this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
+            <summary>
+            Checks if the message level is below this appender's threshold.
+            </summary>
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
+            <remarks>
+            <para>
+            If there is no threshold set, then the return value is always <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
+            requirements of this appender.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
+            <summary>
+            Is called when the appender is closed. Derived classes should override 
+            this method if resources need to be released.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
+            to perform actual logging.
+            </summary>
+            <param name="loggingEvent">The event to append.</param>
+            <remarks>
+            <para>
+            A subclass must implement this method to perform
+            logging of the <paramref name="loggingEvent"/>.
+            </para>
+            <para>This method will be called by <see cref="M:DoAppend(LoggingEvent)"/>
+            if all the conditions listed for that method are met.
+            </para>
+            <para>
+            To restrict the logging of events in the appender
+            override the <see cref="M:PreAppendCheck()"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append a bulk array of logging events.
+            </summary>
+            <param name="loggingEvents">the array of logging events</param>
+            <remarks>
+            <para>
+            This base class implementation calls the <see cref="M:Append(LoggingEvent)"/>
+            method for each element in the bulk array.
+            </para>
+            <para>
+            A sub class that can better process a bulk array of events should
+            override this method in addition to <see cref="M:Append(LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
+            <summary>
+            Called before <see cref="M:Append(LoggingEvent)"/> as a precondition.
+            </summary>
+            <remarks>
+            <para>
+            This method is called by <see cref="M:DoAppend(LoggingEvent)"/>
+            before the call to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            This method can be overridden in a subclass to extend the checks 
+            made before the event is passed to the <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            A subclass should ensure that they delegate this call to
+            this base class if it is overridden.
+            </para>
+            </remarks>
+            <returns><c>true</c> if the call to <see cref="M:Append(LoggingEvent)"/> should proceed.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <returns>The event rendered as a string.</returns>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Where possible use the alternative version of this method
+            <see cref="M:RenderLoggingEvent(TextWriter,LoggingEvent)"/>.
+            That method streams the rendering onto an existing Writer
+            which can give better performance if the caller already has
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>
+            where possible. If, however, the caller needs to render the event
+            to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does
+            provide an efficient mechanism for doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            This implementation doesn't flush anything and always returns true
+            </remarks>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
+            <summary>
+            The layout of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
+            <summary>
+            The name of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
+            <summary>
+            The level threshold of this appender.
+            </summary>
+            <remarks>
+            <para>
+            There is no level threshold filtering by default.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
+            <summary>
+            It is assumed and enforced that errorHandler is never null.
+            </summary>
+            <remarks>
+            <para>
+            It is assumed and enforced that errorHandler is never null.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
+            <summary>
+            The first filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>null</c> initially.
+            </para>
+            <para>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
+            <summary>
+            The last filter in the filter chain.
+            </summary>
+            <remarks>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
+            <summary>
+            Flag indicating if this appender is closed.
+            </summary>
+            <remarks>
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
+            <summary>
+            The guard prevents an appender from repeatedly calling its own DoAppend method
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
+            <summary>
+            StringWriter used to render events
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.declaringType">
+            <summary>
+            The fully qualified type of the AppenderSkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
+            <summary>
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
+            </summary>
+            <value>
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
+            </value>
+            <remarks>
+            <para>
+            All log events with lower level than the threshold level are ignored 
+            by the appender.
+            </para>
+            <para>
+            In configuration files this option is specified by setting the
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
+            string, such as "DEBUG", "INFO" and so on.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </summary>
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
+            <summary>
+            The filter chain.
+            </summary>
+            <value>The head of the filter chain filter chain.</value>
+            <remarks>
+            <para>
+            Returns the head Filter. The Filters are organized in a linked list
+            and so all Filters on this Appender are available through the result.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
+            </summary>
+            <value>The layout of the appender.</value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>
+            The name uniquely identifies the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
+            <summary>
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <remarks>
+            <para>
+            In the rather exceptional case, where the appender 
+            implementation admits a layout but can also work without it, 
+            then the appender should return <c>true</c>.
+            </para>
+            <para>
+            This default implementation always returns <c>false</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
+            <summary>
+            The default buffer size.
+            </summary>
+            <remarks>
+            The default size of the cyclic buffer used to store events.
+            This is set to 512 by default.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <param name="eventMustBeFixed">the events passed through this appender must be
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
+            <remarks>
+            <para>
+            Protected constructor to allow subclassing.
+            </para>
+            <para>
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass
+            expects the events delivered to be fixed even if the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <remarks>
+            <para>
+            Flushes any events that have been buffered.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will NOT be flushed to the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
+            <remarks>
+            <para>
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
+            In this case the contents of the buffer will be tested against the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
+            events will be discarded.
+            </para>
+            <para>
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
+            be emptied by calling this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
+            <summary>
+            Close this appender instance.
+            </summary>
+            <remarks>
+            <para>
+            Close this appender instance. If this appender is marked
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
+            the buffer must be sent when the appender is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
+            </para>
+            <para>
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
+            method) if one of the following conditions is met:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>The cyclic buffer is full and this appender is
+            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
+            	</item>
+            	<item>
+            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
+            		it is triggered for the <paramref name="loggingEvent"/>
+            		specified.</description>
+            	</item>
+            </list>
+            <para>
+            Before the event is stored in the buffer it is fixed
+            (see <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/>) to ensure that
+            any data referenced by the event will be valid when the buffer
+            is processed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
+            <summary>
+            Sends the contents of the buffer.
+            </summary>
+            <param name="firstLoggingEvent">The first logging event.</param>
+            <param name="buffer">The buffer containing the events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override this method to process the buffered events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
+            <summary>
+            The size of the cyclic buffer used to hold the logging events.
+            </summary>
+            <remarks>
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
+            <summary>
+            The cyclic buffer used to store the logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
+            <summary>
+            The triggering event evaluator that causes the buffer to be sent immediately.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event causes the entire
+            buffer to be sent immediately. This field can be <c>null</c>, which 
+            indicates that event triggering is not to be done. The evaluator
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
+            <summary>
+            Indicates if the appender should overwrite events in the cyclic buffer 
+            when it becomes full, or if the buffer should be flushed when the 
+            buffer is full.
+            </summary>
+            <remarks>
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
+            be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
+            <summary>
+            The triggering event evaluator filters discarded events.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event that is discarded should
+            really be discarded or if it should be sent to the appenders. 
+            This field can be <c>null</c>, which indicates that all discarded events will
+            be discarded. 
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
+            <summary>
+            The events delivered to the subclass must be fixed.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
+            <summary>
+            Gets or sets a value that indicates whether the appender is lossy.
+            </summary>
+            <value>
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            This appender uses a buffer to store logging events before 
+            delivering them. A triggering event causes the whole buffer
+            to be send to the remote sink. If the buffer overruns before
+            a triggering event then logging events could be lost. Set
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
+            from being lost.
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
+            <summary>
+            Gets or sets the size of the cyclic buffer used to hold the 
+            logging events.
+            </summary>
+            <value>
+            The size of the cyclic buffer used to hold the logging events.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
+            representing the maximum number of logging events to collect in 
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
+            oldest events are deleted as new events are added to the
+            buffer. By default the size of the cyclic buffer is 512 events.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
+            or equal to 1 then no buffering will occur. The logging event
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
+            be buffered.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
+            buffer to be sent immediately.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
+            sent immediately.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is appended to this 
+            appender. If the evaluator triggers then the current buffer will 
+            immediately be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
+            <summary>
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </summary>
+            <value>
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is discarded from this 
+            appender. If the evaluator triggers then the current buffer will immediately 
+            be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating if only part of the logging event data
+            should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the
+            event data to be fixed and serialized. This will improve performance.
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
+            <summary>
+            Gets or sets a the fields that will be fixed in the event
+            </summary>
+            <value>
+            The event fields that will be fixed before the event is buffered
+            </value>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
+            <summary> 
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
+            </summary>
+            <remarks>
+            Public default constructor to initialize a new instance of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
+            <summary>
+            Override the parent method to close the database
+            </summary>
+            <remarks>
+            <para>
+            Closes the database command and database connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Inserts the events into the database.
+            </summary>
+            <param name="events">The events to insert into the database.</param>
+            <remarks>
+            <para>
+            Insert all the events specified in the <paramref name="events"/>
+            array into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
+            <summary>
+            Adds a parameter to the command.
+            </summary>
+            <param name="parameter">The parameter to add to the command.</param>
+            <remarks>
+            <para>
+            Adds a parameter to the ordered list of command parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
+            <summary>
+            Writes the events to the database using the transaction specified.
+            </summary>
+            <param name="dbTran">The transaction that the events will be executed under.</param>
+            <param name="events">The array of events to insert into the database.</param>
+            <remarks>
+            <para>
+            The transaction argument can be <c>null</c> if the appender has been
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
+            property for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
+            <summary>
+            Formats the log message into database statement text.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            This method can be overridden by subclasses to provide 
+            more control over the format of the database statement.
+            </remarks>
+            <returns>
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.CreateConnection(System.Type,System.String)">
+            <summary>
+            Creates an <see cref="T:System.Data.IDbConnection"/> instance used to connect to the database.
+            </summary>
+            <remarks>
+            This method is called whenever a new IDbConnection is needed (i.e. when a reconnect is necessary).
+            </remarks>
+            <param name="connectionType">The <see cref="T:System.Type"/> of the <see cref="T:System.Data.IDbConnection"/> object.</param>
+            <param name="connectionString">The connectionString output from the ResolveConnectionString method.</param>
+            <returns>An <see cref="T:System.Data.IDbConnection"/> instance with a valid connection string.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionString(System.String@)">
+            <summary>
+            Resolves the connection string from the ConnectionString, ConnectionStringName, or AppSettingsKey
+            property.
+            </summary>
+            <remarks>
+            ConnectiongStringName is only supported on .NET 2.0 and higher.
+            </remarks>
+            <param name="connectionStringContext">Additional information describing the connection string.</param>
+            <returns>A connection string used to connect to the database.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
+            <summary>
+            Retrieves the class type of the ADO.NET provider.
+            </summary>
+            <remarks>
+            <para>
+            Gets the Type of the ADO.NET provider to use to connect to the
+            database. This method resolves the type specified in the 
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
+            </para>
+            <para>
+            Subclasses can override this method to return a different type
+            if necessary.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
+            <summary>
+            Connects to the database.
+            </summary>		
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.DiposeConnection">
+            <summary>
+            Cleanup the existing connection.
+            </summary>
+            <remarks>
+            Calls the IDbConnection's <see cref="M:System.Data.IDbConnection.Close"/> method.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
+            <summary>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </summary>
+            <remarks>
+            <para>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
+            <summary>
+            The <see cref="T:System.Data.IDbConnection"/> that will be used
+            to insert logging events into a database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
+            <summary>
+            Database connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_appSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
+            <summary>
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
+            <summary>
+            The text of the command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
+            <summary>
+            The command type.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
+            <summary>
+            Indicates whether to reconnect when a connection is lost.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.declaringType">
+            <summary>
+            The fully qualified type of the AdoNetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
+            <summary>
+            Gets or sets the database connection string that is used to connect to 
+            the database.
+            </summary>
+            <value>
+            The database connection string used to connect to the database.
+            </value>
+            <remarks>
+            <para>
+            The connections string is specific to the connection type.
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
+            </para>
+            </remarks>
+            <example>Connection string for MS Access via ODBC:
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
+            </example>
+            <example>Another connection string for MS Access via ODBC:
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
+            </example>
+            <example>Connection string for MS Access via OLE DB:
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.AppSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+            <remarks>
+            This property requires at least .NET 2.0.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
+            <summary>
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
+            that should be created.
+            </summary>
+            <value>
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
+            </value>
+            <remarks>
+            <para>
+            The type name of the ADO.NET provider to use.
+            </para>
+            <para>
+            The default is to use the OLE DB provider.
+            </para>
+            </remarks>
+            <example>Use the OLE DB Provider. This is the default value.
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the MS SQL Server Provider. 
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the ODBC Provider. 
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>ODBC .NET Data Provider</b>.
+            </example>
+            <example>Use the Oracle Provider. 
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>.NET Managed Provider for Oracle</b>.
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
+            <summary>
+            Gets or sets the command text that is used to insert logging events
+            into the database.
+            </summary>
+            <value>
+            The command text used to insert logging events into the database.
+            </value>
+            <remarks>
+            <para>
+            Either the text of the prepared statement or the
+            name of the stored procedure to execute to write into
+            the database.
+            </para>
+            <para>
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
+            this text is a prepared statement or a stored procedure.
+            </para>
+            <para>
+            If this property is not set, the command text is retrieved by invoking
+            <see cref="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
+            <summary>
+            Gets or sets the command type to execute.
+            </summary>
+            <value>
+            The command type to execute.
+            </value>
+            <remarks>
+            <para>
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
+            to execute.
+            </para>
+            <para>
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
+            <summary>
+            Should transactions be used to insert logging events in the database.
+            </summary>
+            <value>
+            <c>true</c> if transactions should be used to insert logging events in
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a value that indicates whether transactions should be used
+            to insert logging events in the database.
+            </para>
+            <para>
+            When set a single transaction will be used to insert the buffered events
+            into the database. Otherwise each event will be inserted without using
+            an explicit transaction.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
+            <summary>
+            Should this appender try to reconnect to the database on error.
+            </summary>
+            <value>
+            <c>true</c> if the appender should try to reconnect to the database after an
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
+            i.e. not to try to reconnect.
+            </value>
+            <remarks>
+            <para>
+            The default behaviour is for the appender not to try to reconnect to the
+            database if an error occurs. Subsequent logging events are discarded.
+            </para>
+            <para>
+            To force the appender to attempt to reconnect to the database set this
+            property to <c>true</c>.
+            </para>
+            <note>
+            When the appender attempts to connect to the database there may be a
+            delay of up to the connection timeout specified in the connection string.
+            This delay will block the calling application's thread. 
+            Until the connection can be reestablished this potential delay may occur multiple times.
+            </note>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Data.IDbConnection"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">
+            <summary>
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            This class provides the basic database parameter properties
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
+            </para>
+            <para>This type can be subclassed to provide database specific
+            functionality. The two methods that are called externally are
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.
+            </summary>
+            <remarks>
+            Default constructor for the AdoNetAppenderParameter class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">
+            <summary>
+            Prepare the specified database command object.
+            </summary>
+            <param name="command">The command to prepare.</param>
+            <remarks>
+            <para>
+            Prepares the database command object by adding
+            this parameter to its collection of parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the logging event and set the parameter value in the command.
+            </summary>
+            <param name="command">The command containing the parameter.</param>
+            <param name="loggingEvent">The event to be rendered.</param>
+            <remarks>
+            <para>
+            Renders the logging event using this parameters layout
+            object. Sets the value of the parameter on the command object.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">
+            <summary>
+            The name of this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">
+            <summary>
+            The database type for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">
+            <summary>
+            Flag to infer type rather than use the DbType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">
+            <summary>
+            The precision for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">
+            <summary>
+            The scale for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">
+            <summary>
+            The size for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">
+            <summary>
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the
+            logging event into an object for this parameter.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">
+            <summary>
+            Gets or sets the name of this parameter.
+            </summary>
+            <value>
+            The name of this parameter.
+            </value>
+            <remarks>
+            <para>
+            The name of this parameter. The parameter name
+            must match up to a named parameter to the SQL stored procedure
+            or prepared statement.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">
+            <summary>
+            Gets or sets the database type for this parameter.
+            </summary>
+            <value>
+            The database type for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The database type for this parameter. This property should
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the type from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">
+            <summary>
+            Gets or sets the precision for this parameter.
+            </summary>
+            <value>
+            The precision for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum number of digits used to represent the Value.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the precision from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">
+            <summary>
+            Gets or sets the scale for this parameter.
+            </summary>
+            <value>
+            The scale for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The number of decimal places to which Value is resolved.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the scale from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">
+            <summary>
+            Gets or sets the size for this parameter.
+            </summary>
+            <value>
+            The size for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum size, in bytes, of the data within the column.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the size from the value.
+            </para>
+            <para>
+            For BLOB data types like VARCHAR(max) it may be impossible to infer the value automatically, use -1 as the size in this case.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to 
+            render the logging event into an object for this 
+            parameter.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the
+            logging event into an object for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this
+            parameter.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>
+            for use in the property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">
+            <summary>
+            Appends logging events to the terminal using ANSI color escape sequences.
+            </summary>
+            <remarks>
+            <para>
+            AnsiColorTerminalAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific level of message to be set.
+            </para>
+            <note>
+            This appender expects the terminal to understand the VT100 control set 
+            in order to interpret the color codes. If the terminal or console does not
+            understand the control codes the behavior is not defined.
+            </note>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            <para>
+            When configuring the ANSI colored terminal appender, a mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red"/>
+                <attributes value="Bright,Underscore"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            </list>
+            These color values cannot be combined together to make new colors.
+            </para>
+            <para>
+            The attributes can be any combination of the following:
+            <list type="bullet">
+            <item><term>Bright</term><description>foreground is brighter</description></item>
+            <item><term>Dim</term><description>foreground is dimmer</description></item>
+            <item><term>Underscore</term><description>message is underlined</description></item>
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>
+            <item><term>Hidden</term><description>output is hidden</description></item>
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>
+            </list>
+            While any of these attributes may be combined together not all combinations
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes
+            no sense.
+            </para>
+            </remarks>
+            <author>Patrick Wagstrom</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">
+            <summary>
+            Ansi code to reset terminal
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colours
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">
+            <summary>
+            The enum of possible display attributes
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the ANSI color attributes.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">
+            <summary>
+            text is bright
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">
+            <summary>
+            text is dim
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">
+            <summary>
+            text is underlined
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">
+            <summary>
+            text is blinking
+            </summary>
+            <remarks>
+            Not all terminals support this attribute
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">
+            <summary>
+            text and background colors are reversed
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">
+            <summary>
+            text is hidden
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">
+            <summary>
+            text is displayed with a strikethrough
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Light">
+            <summary>
+            text color is light
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">
+            <summary>
+            The enum of possible foreground or background color values for 
+            use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The output can be in one for the following ANSI colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">
+            <summary>
+            color is black
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">
+            <summary>
+            color is magenta
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMappingEntry">
+            <summary>
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract base class for types that are stored in the
+            <see cref="T:log4net.Util.LevelMapping"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">
+            <summary>
+            Default protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Default protected constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
+            <summary>
+            Initialize any options defined on this entry
+            </summary>
+            <remarks>
+            <para>
+            Should be overridden by any classes that need to initialise based on their options
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LevelMappingEntry.Level">
+            <summary>
+            The level that is the key for this mapping 
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping 
+            </value>
+            <remarks>
+            <para>
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
+            mapping subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together
+            and append the attributes.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">
+            <summary>
+            The color attributes for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The color attributes for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            An <c>AppenderCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">
+            <summary>
+            An empty readonly static AppenderCollection
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <c>AppenderCollection</c>.
+            </summary>
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">
+            <summary>
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clear">
+            <summary>
+            Removes all elements from the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>
+            in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">
+            <summary>
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">
+            <summary>
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">
+            <summary>
+            Return the collection elements as an array
+            </summary>
+            <returns>the array</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            	<para><paramref name="index"/> is less than zero</para>
+            	<para>-or-</para>
+            	<para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Appender.BufferingForwardingAppender">
+            <summary>
+            Buffers events and then forwards them to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The events are buffered in this appender until conditions are
+            met to allow the appender to deliver the events to the attached 
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the
+            conditions that cause the buffer to be sent.
+            </para>
+            <para>The forwarding appender can be used to specify different 
+            thresholds and filters for the same appender at different locations 
+            within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Core.IAppenderAttachable">
+            <summary>
+            Interface for attaching appenders to objects.
+            </summary>
+            <remarks>
+            <para>
+            Interface for attaching, removing and retrieving appenders.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="appender">The appender to add.</param>
+            <remarks>
+            <para>
+            Add the specified appender. The implementation may
+            choose to allow or deny duplicate appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Returns an attached appender with the <paramref name="name"/> specified.
+            If no appender with the specified name is found <c>null</c> will be
+            returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <value>
+            A collection of attached appenders.
+            </value>
+            <remarks>
+            <para>
+            Gets a collection of attached appenders.
+            If there are no attached appenders the
+            implementation should return an empty 
+            collection rather than <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            Forwards the events to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this buffering appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes directly to the application's attached console
+            not to the <c>System.Console.Out</c> or <c>System.Console.Error</c> <c>TextWriter</c>.
+            The <c>System.Console.Out</c> and <c>System.Console.Error</c> streams can be
+            programmatically redirected (for example NUnit does this to capture program output).
+            This appender will ignore these redirections because it needs to use Win32
+            API calls to colorize the output. To respect these redirections the <see cref="T:log4net.Appender.ConsoleAppender"/>
+            must be used.
+            </para>
+            <para>
+            When configuring the colored console appender, mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red, HighIntensity"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            combination of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            <item><term>HighIntensity</term><description></description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.AddMapping(log4net.Appender.ColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_consoleOutputWriter">
+            <summary>
+            The console output stream writer to write to
+            </summary>
+            <remarks>
+            <para>
+            This writer is not thread safe.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.Colors">
+            <summary>
+            The enum of possible color values for use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.ColoredConsoleAppender"/>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Purple">
+            <summary>
+            color is purple
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.HighIntensity">
+            <summary>
+            color is intensified
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> together.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> suitable for 
+            setting the console color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.DebugAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the
+            debug system.
+            </para>
+            <para>
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(string,string)"/>
+            method. The event's logger name is passed as the value for the category name to the Write method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>
+            is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_category">
+            <summary>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.Category">
+            <summary>
+            Formats the category parameter sent to the Debug method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender">
+            <summary>
+            Writes events to the system event log.
+            </summary>
+            <remarks>
+            <para>
+            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.
+            See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog
+            </para>
+            <para>
+            The <c>EventID</c> of the event log entry can be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            The <c>Category</c> of the event log entry can be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            <para>
+            When configuring the EventLogAppender a mapping can be
+            specified to map a logging level to an event log entry type. For example:
+            </para>
+            <code lang="XML">
+            &lt;mapping&gt;
+            	&lt;level value="ERROR" /&gt;
+            	&lt;eventLogEntryType value="Error" /&gt;
+            &lt;/mapping&gt;
+            &lt;mapping&gt;
+            	&lt;level value="DEBUG" /&gt;
+            	&lt;eventLogEntryType value="Information" /&gt;
+            &lt;/mapping&gt;
+            </code>
+            <para>
+            The Level is the standard log4net logging level and eventLogEntryType can be any value
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:
+            <list type="bullet">
+            <item><term>Error</term><description>an error event</description></item>
+            <item><term>Warning</term><description>a warning event</description></item>
+            <item><term>Information</term><description>an informational event</description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Thomas Voss</author>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.
+            </summary>
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">
+            <summary>
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.
+            Each mapping defines the event log entry type for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">
+            <summary>
+            Create an event log source
+            </summary>
+            <remarks>
+            Uses different API calls under NET_2_0
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Writes the event to the system event log using the 
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>
+            
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            set then this integer will be used as the event log event id.</para>
+            
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">
+            <summary>
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/>
+            </summary>
+            <param name="level">the Level to convert to an EventLogEntryType</param>
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/></returns>
+            <remarks>
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
+            values to use in logging levels than there are in the 
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is
+            a loss of information during the conversion.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">
+            <summary>
+            The log name is the section in the event logs where the messages
+            are stored.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
+            <summary>
+            Name of the application to use when logging.  This appears in the
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
+            <summary>
+            The name of the machine which holds the event log. This is
+            currently only allowed to be '.' i.e. the current machine.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to EventLogEntryType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_eventId">
+            <summary>
+            The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_category">
+            <summary>
+            The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.declaringType">
+            <summary>
+            The fully qualified type of the EventLogAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_DEFAULT">
+            <summary>
+            The maximum size supported by default.
+            </summary>
+            <remarks>
+            http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx
+            The 32766 documented max size is two bytes shy of 32K (I'm assuming 32766 
+            may leave space for a two byte null terminator of #0#0). The 32766 max 
+            length is what the .NET 4.0 source code checks for, but this is WRONG! 
+            Strings with a length > 31839 on Windows Vista or higher can CORRUPT 
+            the event log! See: System.Diagnostics.EventLogInternal.InternalWriteEvent() 
+            for the use of the 32766 max size.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_VISTA_OR_NEWER">
+            <summary>
+            The maximum size supported by a windows operating system that is vista
+            or newer.
+            </summary>
+            <remarks>
+            See ReportEvent API:
+            	http://msdn.microsoft.com/en-us/library/aa363679(VS.85).aspx
+            ReportEvent's lpStrings parameter:
+            "A pointer to a buffer containing an array of 
+            null-terminated strings that are merged into the message before Event Viewer 
+            displays the string to the user. This parameter must be a valid pointer 
+            (or NULL), even if wNumStrings is zero. Each string is limited to 31,839 characters."
+            
+            Going beyond the size of 31839 will (at some point) corrupt the event log on Windows
+            Vista or higher! It may succeed for a while...but you will eventually run into the
+            error: "System.ComponentModel.Win32Exception : A device attached to the system is
+            not functioning", and the event log will then be corrupt (I was able to corrupt 
+            an event log using a length of 31877 on Windows 7).
+            
+            The max size for Windows Vista or higher is documented here:
+            	http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx.
+            Going over this size may succeed a few times but the buffer will overrun and 
+            eventually corrupt the log (based on testing).
+            
+            The maxEventMsgSize size is based on the max buffer size of the lpStrings parameter of the ReportEvent API.
+            The documented max size for EventLog.WriteEntry for Windows Vista and higher is 31839, but I'm leaving room for a
+            terminator of #0#0, as we cannot see the source of ReportEvent (though we could use an API monitor to examine the
+            buffer, given enough time).
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE">
+            <summary>
+            The maximum size that the operating system supports for
+            a event log message.
+            </summary>
+            <remarks>
+            Used to determine the maximum string length that can be written
+            to the operating system event log and eventually truncate a string
+            that exceeds the limits.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetMaxEventLogMessageSize">
+            <summary>
+            This method determines the maximum event log message size allowed for
+            the current environment.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.LogName">
+            <summary>
+            The name of the log where messages will be stored.
+            </summary>
+            <value>
+            The string name of the log where messages will be stored.
+            </value>
+            <remarks>
+            <para>This is the name of the log as it appears in the Event Viewer
+            tree. The default value is to log into the <c>Application</c>
+            log, this is where most applications write their events. However
+            if you need a separate log for your application (or applications)
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
+            <para>This should not be used to distinguish your event log messages
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
+            property should be used to distinguish events. This property should be 
+            used to group together events into a single log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
+            <summary>
+            Property used to set the Application name.  This appears in the
+            event logs when logging.
+            </summary>
+            <value>
+            The string used to distinguish events from different sources.
+            </value>
+            <remarks>
+            Sets the event log source property.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">
+            <summary>
+            This property is used to return the name of the computer to use
+            when accessing the event logs.  Currently, this is the current
+            computer, denoted by a dot "."
+            </summary>
+            <value>
+            The string name of the machine holding the event log that 
+            will be logged into.
+            </value>
+            <remarks>
+            This property cannot be changed. It is currently set to '.'
+            i.e. the local machine. This may be changed in future.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </value>
+            <remarks>
+            <para>
+            The system security context used to write to the EventLog.
+            </para>
+            <para>
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.EventId">
+            <summary>
+            Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>EventID</c> of the event log entry will normally be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Category">
+            <summary>
+            Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Category</c> of the event log entry will normally be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and its event log entry type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">
+            <summary>
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender">
+            <summary>
+            Appends logging events to a file.
+            </summary>
+            <remarks>
+            <para>
+            Logging events are sent to the file specified by
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.
+            </para>
+            <para>
+            The file can be opened in either append or overwrite mode 
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.
+            If the file path is relative it is taken as relative from 
+            the application base directory. The file encoding can be
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.
+            </para>
+            <para>
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            values will be written each time the file is opened and closed
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>
+            then the file may contain multiple copies of the header and footer.
+            </para>
+            <para>
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> 
+            is to obtain an exclusive write lock on the file until this appender is closed.
+            The alternative models only hold a
+            write lock while the appender is writing a logging event (<see cref="T:log4net.Appender.FileAppender.MinimalLock"/>)
+            or synchronize by using a named system wide Mutex (<see cref="T:log4net.Appender.FileAppender.InterProcessLock"/>).
+            </para>
+            <para>
+            All locking strategies have issues and you should seriously consider using a different strategy that
+            avoids having multiple processes logging to the same file.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Rodrigo B. de Oliveira</author>
+            <author>Douglas de la Torre</author>
+            <author>Niall Daley</author>
+        </member>
+        <member name="T:log4net.Appender.TextWriterAppender">
+            <summary>
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This appender may be used stand alone if initialized with an appropriate
+            writer, however it is typically used as a base class for an appender that
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized 
+            with the specified <see cref="T:System.IO.Stream"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender</param>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
+            <remarks>
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
+            <summary>
+            This method determines if there is a sense in attempting to append.
+            </summary>
+            <remarks>
+            <para>
+            This method checks if an output target has been set and if a
+            layout has been set. 
+            </para>
+            </remarks>
+            <returns><c>false</c> if any of the preconditions fail.</returns>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method writes all the bulk logged events to the output writer
+            before flushing the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+            <remarks>
+            Closed appenders cannot be reused.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
+            <summary>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">
+            <summary>
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> 
+            and other variables.
+            </summary>
+            <remarks>
+            <para>
+            Subclasses can override this method for an alternate closing behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
+            <summary>
+            Called to allow a subclass to lazily initialize the writer
+            </summary>
+            <remarks>
+            <para>
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
+            attempt to initialize the writer multiple times.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
+            <summary>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> 
+            or output stream will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logging events are not actually persisted if and when the application 
+            crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.declaringType">
+            <summary>
+            The fully qualified type of the TextWriterAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
+            <summary>
+            Gets or set whether the appender will flush at the end 
+            of each append operation.
+            </summary>
+            <value>
+            <para>
+            The default behavior is to flush at the end of each 
+            append operation.
+            </para>
+            <para>
+            If this option is set to <c>false</c>, then the underlying 
+            stream can defer persisting the logging event to a later 
+            time.
+            </para>
+            </value>
+            <remarks>
+            Avoiding the flush operation at the end of each append results in
+            a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">
+            <summary>
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
+            </summary>
+            <remarks>
+            <para>
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
+            </para>
+            <para>
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender 
+            instance is closed.
+            </para>
+            <para>
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
+            <summary>
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying 
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </value>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
+            </value>
+            <remarks>
+            <para>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
+            <summary>
+            Construct a new appender using the layout, file and append mode.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <param name="append">flag to indicate if the file should be appended to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
+            <summary>
+            Construct a new appender using the layout and file specified.
+            The file will be appended to.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
+            <summary>
+            Activate the options on the file appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This will cause the file to be opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Reset">
+            <summary>
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.
+            </summary>
+            <remarks>
+            <para>
+            Resets the filename and the file stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">
+            <summary>
+            Called to initialize the file writer
+            </summary>
+            <remarks>
+            <para>
+            Will be called for each logged message until the file is
+            successfully opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Acquires the output file locks once before writing all the events to
+            the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseFile">
+            <summary>
+            Closes the previously opened file.
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then
+            closes the file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            If there was already an opened file, then the previous file
+            is closed first.
+            </para>
+            <para>
+            This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">
+            <summary>
+            Sets the quiet writer used for file output
+            </summary>
+            <param name="fileStream">the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This implementation of <see cref="M:SetQWForFiles(Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>
+            over the <paramref name="fileStream"/> and passes it to the 
+            <see cref="M:SetQWForFiles(TextWriter)"/> method.
+            </para>
+            <para>
+            This method can be overridden by sub classes that want to wrap the
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <param name="writer">the writer over the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This method can be overridden by sub classes that want to
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
+            <summary>
+            Flag to indicate if we should append to the file
+            or overwrite the file. The default is to append.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_fileName">
+            <summary>
+            The name of the log file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_encoding">
+            <summary>
+            The encoding to use for the file stream.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_stream">
+            <summary>
+            The stream to log to. Has added locking semantics
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">
+            <summary>
+            The locking model to use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.declaringType">
+            <summary>
+            The fully qualified type of the FileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.File">
+            <summary>
+            Gets or sets the path to the file that logging will be written to.
+            </summary>
+            <value>
+            The path to the file that logging will be written to.
+            </value>
+            <remarks>
+            <para>
+            If the path is relative it is taken as relative from 
+            the application base directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">
+            <summary>
+            Gets or sets a flag that indicates whether the file should be
+            appended to or overwritten.
+            </summary>
+            <value>
+            Indicates whether the file should be appended to or overwritten.
+            </value>
+            <remarks>
+            <para>
+            If the value is set to false then the file will be overwritten, if 
+            it is set to true then the file will be appended to.
+            </para>
+            The default value is true.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>
+            which is the encoding for the system's current ANSI code page.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModel">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </para>
+            <para>
+            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"/> .
+            The first locks the file from the start of logging to the end, the 
+            second locks only for the minimal amount of time when logging each message
+            and the last synchronizes processes using a named system wide Mutex.
+            </para>
+            <para>
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingStream">
+            <summary>
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> 
+            to manage access to an underlying resource.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
+            <summary>
+            True asynchronous writes are not supported, the implementation forces a synchronous write.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LogException">
+            <summary>
+            Exception base type for log4net.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with
+            the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">
+            <summary>
+            Locking model base class
+            </summary>
+            <remarks>
+            <para>
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the output file
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CreateStream(System.String,System.Boolean,System.IO.FileShare)">
+            <summary>
+            Helper method that creates a FileStream under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            <para>
+            Typically called during OpenFile or AcquireLock. 
+            </para>
+            <para>
+            If the directory portion of the <paramref name="filename"/> does not exist, it is created
+            via Directory.CreateDirecctory.
+            </para>
+            </remarks>
+            <param name="filename"></param>
+            <param name="append"></param>
+            <param name="fileShare"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseStream(System.IO.Stream)">
+            <summary>
+            Helper method to close <paramref name="stream"/> under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            Does not set <paramref name="stream"/> to null.
+            </remarks>
+            <param name="stream"></param>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </summary>
+            <value>
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </value>
+            <remarks>
+            <para>
+            The file appender this locking model is attached to and working on
+            behalf of.
+            </para>
+            <para>
+            The file appender is used to locate the security context and the error handler to use.
+            </para>
+            <para>
+            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
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">
+            <summary>
+            Hold an exclusive lock on the output file
+            </summary>
+            <remarks>
+            <para>
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. 
+            Maintains an exclusive lock on the file during this time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Does nothing. The lock will be released when the file is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">
+            <summary>
+            Acquires the file lock for each write
+            </summary>
+            <remarks>
+            <para>
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, 
+            thus holding the lock for the minimal amount of time. This method of locking
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows 
+            other processes to move/delete the log file whilst logging continues.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Prepares to open the file when the first message is logged.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.InterProcessLock">
+            <summary>
+            Provides cross-process file locking.
+            </summary>
+            <author>Ron Grabowski</author>
+            <author>Steve Wranovsky</author>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/>,
+            -<see cref="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock">
+            <summary>
+            Releases the lock and allows others to acquire a lock.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ForwardingAppender">
+            <summary>
+            This appender forwards logging events to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The forwarding appender can be used to specify different thresholds
+            and filters for the same appender at different locations within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Forward the logging event to the attached appenders 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Forward the logging events to the attached appenders 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging events to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender">
+            <summary>
+            Logs events to a local syslog service.
+            </summary>
+            <remarks>
+            <note>
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.
+            If these functions are not available on the local system then this appender will not work!
+            </note>
+            <para>
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and 
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.
+            </para>
+            <para>
+            This appender talks to a local syslog service. If you need to log to a remote syslog
+            daemon and you cannot configure your local syslog service to do this you may be
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write 
+            to a local syslog service.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">
+            <summary>
+            Close the syslog when the appender is closed
+            </summary>
+            <remarks>
+            <para>
+            Close the syslog when the appender is closed
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">
+            <summary>
+            Marshaled handle to the identity string. We have to hold on to the
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the
+            pointer to the ident and dereference it for each log message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">
+            <summary>
+            Open connection to system logger.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">
+            <summary>
+            Generate a log message.
+            </summary>
+            <remarks>
+            <para>
+            The libc syslog method takes a format string and a variable argument list similar
+            to the classic printf function. As this type of vararg list is not supported
+            by C# we need to specify the arguments explicitly. Here we have specified the
+            format string with a single message argument. The caller must set the format 
+            string to <c>"%s"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">
+            <summary>
+            Close descriptor used to write to system logger.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The log4net Level maps to a syslog severity using the
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facility defines which subsystem the logging comes from.
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender">
+            <summary>
+            Appends colorful logging events to the console, using the .NET 2
+            built-in capabilities.
+            </summary>
+            <remarks>
+            <para>
+            ManagedColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            When configuring the colored console appender, mappings should be
+            specified to map logging levels to colors. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="DarkRed"/>
+            	<backColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="WARN"/>
+            	<foreColor value="Yellow"/>
+            </mapping>
+            <mapping>
+            	<level value="INFO"/>
+            	<foreColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<foreColor value="Blue"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level while
+            ForeColor and BackColor are the values of <see cref="T:System.ConsoleColor"/>
+            enumeration.
+            </para>
+            <para>
+            Based on the ColoredConsoleAppender
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+            <author>Pavlos Touboulidis</author>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.AddMapping(log4net.Appender.ManagedColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.MemoryAppender">
+            <summary>
+            Stores logging events in an array.
+            </summary>
+            <remarks>
+            <para>
+            The memory appender stores all the logging events
+            that are appended in an in-memory array.
+            </para>
+            <para>
+            Use the <see cref="M:PopAllEvents()"/> method to get
+            and clear the current list of events that have been appended.
+            </para>
+            <para>
+            Use the <see cref="M:GetEvents()"/> method to get the current
+            list of events that have been appended.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            <para>
+            Use the <see cref="M:Clear()"/> method to clear the
+            current list of events.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            </remarks>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">
+            <summary>
+            Gets the events that have been logged.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Clear">
+            <summary>
+            Clear the list of events
+            </summary>
+            <remarks>
+            Clear the list of events
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.PopAllEvents">
+            <summary>
+            Gets the events that have been logged and clears the list of events.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged and clears the list of events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
+            <summary>
+            The list of events that have been appended.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating whether only part of the logging event 
+            data should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the event 
+            data to be fixed and stored in the appender, hereby improving performance. 
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(bool)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.Fix">
+            <summary>
+            Gets or sets the fields that will be fixed in the event
+            </summary>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.NetSendAppender">
+            <summary>
+            Logs entries by sending network messages using the 
+            <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> native function.
+            </summary>
+            <remarks>
+            <para>
+            You can send messages only to names that are active 
+            on the network. If you send the message to a user name, 
+            that user must be logged on and running the Messenger 
+            service to receive the message.
+            </para>
+            <para>
+            The receiver will get a top most window displaying the 
+            messages one at a time, therefore this appender should 
+            not be used to deliver a high volume of messages.
+            </para>
+            <para>
+            The following table lists some possible uses for this appender :
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Action</term>
+                    <description>Property Value(s)</description>
+                </listheader>
+                <item>
+                    <term>Send a message to a user account on the local machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a user account on a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the remote machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a domain user account</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of a domain controller | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to all the names in a workgroup or domain</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;workgroup name | domain name&gt;*
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message from the local machine to a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;name of the remote machine&gt;
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            <b>Note :</b> security restrictions apply for sending 
+            network messages, see <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> 
+            for more information.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            An example configuration section to log information 
+            using this appender from the local machine, named 
+            LOCAL_PC, to machine OPERATOR_PC :
+            </para>
+            <code lang="XML" escaped="true">
+            <appender name="NetSendAppender_Operator" type="log4net.Appender.NetSendAppender">
+                <server value="LOCAL_PC"/>
+                <recipient value="OPERATOR_PC"/>
+                <layout type="log4net.Layout.PatternLayout" value="%-5p %c [%x] - %m%n"/>
+            </appender>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_server">
+            <summary>
+            The DNS or NetBIOS name of the server on which the function is to execute.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_sender">
+            <summary>
+            The sender of the network message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_recipient">
+            <summary>
+            The message alias to which the message should be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.#ctor">
+            <summary>
+            Initializes the appender.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was not specified.</exception>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using a network message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)">
+            <summary>
+            Sends a buffer of information to a registered message alias.
+            </summary>
+            <param name="serverName">The DNS or NetBIOS name of the server on which the function is to execute.</param>
+            <param name="msgName">The message alias to which the message buffer should be sent</param>
+            <param name="fromName">The originator of the message.</param>
+            <param name="buffer">The message text.</param>
+            <param name="bufferSize">The length, in bytes, of the message text.</param>
+            <remarks>
+            <para>
+            The following restrictions apply for sending network messages:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Platform</term>
+                    <description>Requirements</description>
+                </listheader>
+                <item>
+                    <term>Windows NT</term>
+                    <description>
+                        <para>
+                        No special group membership is required to send a network message.
+                        </para>
+                        <para>
+                        Admin, Accounts, Print, or Server Operator group membership is required to 
+                        successfully send a network message on a remote server.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Windows 2000 or later</term>
+                    <description>
+                        <para>
+                        If you send a message on a domain controller that is running Active Directory, 
+                        access is allowed or denied based on the access control list (ACL) for the securable 
+                        object. The default ACL permits only Domain Admins and Account Operators to send a network message. 
+                        </para>
+                        <para>
+                        On a member server or workstation, only Administrators and Server Operators can send a network message. 
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            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>.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is zero.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Sender">
+            <summary>
+            Gets or sets the sender of the message.
+            </summary>
+            <value>
+            The sender of the message.
+            </value>
+            <remarks>
+            If this property is not specified, the message is sent from the local computer.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Recipient">
+            <summary>
+            Gets or sets the message alias to which the message should be sent.
+            </summary>
+            <value>
+            The recipient of the message.
+            </value>
+            <remarks>
+            This property should always be specified in order to send a message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Server">
+            <summary>
+            Gets or sets the DNS or NetBIOS name of the remote server on which the function is to execute.
+            </summary>
+            <value>
+            DNS or NetBIOS name of the remote server on which the function is to execute.
+            </value>
+            <remarks>
+            <para>
+            For Windows NT 4.0 and earlier, the string should begin with \\.
+            </para>
+            <para>
+            If this property is not specified, the local computer is used. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.OutputDebugStringAppender">
+            <summary>
+            Appends log events to the OutputDebugString system.
+            </summary>
+            <remarks>
+            <para>
+            OutputDebugStringAppender appends log events to the
+            OutputDebugString system.
+            </para>
+            <para>
+            The string is passed to the native <c>OutputDebugString</c> 
+            function.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.OutputDebugStringAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the output debug string API
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the output debug string API
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">
+            <summary>
+            Stub for OutputDebugString native method
+            </summary>
+            <param name="message">the string to output</param>
+            <remarks>
+            <para>
+            Stub for OutputDebugString native method
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.OutputDebugStringAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender">
+            <summary>
+            Logs events to a remote syslog daemon.
+            </summary>
+            <remarks>
+            <para>
+            The BSD syslog protocol is used to remotely log to
+            a syslog daemon. The syslogd listens for for messages
+            on UDP port 514.
+            </para>
+            <para>
+            The syslog UDP protocol is not authenticated. Most syslog daemons
+            do not accept remote log messages because of the security implications.
+            You may be able to use the LocalSyslogAppender to talk to a local
+            syslog service.
+            </para>
+            <para>
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.
+            This appender generates what the RFC calls an "Original Device Message",
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation
+            this format of message will be accepted by all current syslog daemon
+            implementations. The daemon will attach the current time and the source
+            hostname or IP address to any messages received.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Appender.UdpAppender">
+             <summary>
+             Sends logging events as connectionless UDP datagrams to a remote host or a 
+             multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.
+             </summary>
+             <remarks>
+             <para>
+             UDP guarantees neither that messages arrive, nor that they arrive in the correct order.
+             </para>
+             <para>
+             To view the logging results, a custom application can be developed that listens for logging 
+             events.
+             </para>
+             <para>
+             When decoding events send via this appender remember to use the same encoding
+             to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>
+             property to specify the encoding to use.
+             </para>
+             </remarks>
+             <example>
+             This example shows how to log receive logging events that are sent 
+             on IP address 244.0.0.1 and port 8080 to the console. The event is 
+             encoded in the packet as a unicode string and it is decoded as such. 
+             <code lang="C#">
+             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+             UdpClient udpClient;
+             byte[] buffer;
+             string loggingEvent;
+             
+             try 
+             {
+                 udpClient = new UdpClient(8080);
+                 
+                 while(true) 
+                 {
+                     buffer = udpClient.Receive(ref remoteEndPoint);
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
+                     Console.WriteLine(loggingEvent);
+                 }
+             } 
+             catch(Exception e) 
+             {
+                 Console.WriteLine(e.ToString());
+             }
+             </code>
+             <code lang="Visual Basic">
+             Dim remoteEndPoint as IPEndPoint
+             Dim udpClient as UdpClient
+             Dim buffer as Byte()
+             Dim loggingEvent as String
+             
+             Try 
+                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
+                 udpClient = new UdpClient(8080)
+            
+                 While True
+                     buffer = udpClient.Receive(ByRef remoteEndPoint)
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
+                     Console.WriteLine(loggingEvent)
+                 Wend
+             Catch e As Exception
+                 Console.WriteLine(e.ToString())
+             End Try
+             </code>
+             <para>
+             An example configuration section to log information using this appender to the 
+             IP 224.0.0.1 on port 8080:
+             </para>
+             <code lang="XML" escaped="true">
+             <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
+                 <remoteAddress value="224.0.0.1"/>
+                 <remotePort value="8080"/>
+                 <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>
+             </appender>
+             </code>
+             </example>
+             <author>Gert Driesen</author>
+             <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or 
+            an invalid remote or local TCP port number was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>
+            <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>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using an UDP datagram.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.OnClose">
+            <summary>
+            Closes the UDP connection and releases all resources associated with 
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed 
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">
+            <summary>
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.
+            </summary>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the 
+            port number from which you intend to communicate.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">
+            <summary>
+            The IP address of the remote host or multicast group to which 
+            the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">
+            <summary>
+            The TCP port number of the remote host or multicast group to 
+            which the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">
+            <summary>
+            The cached remote endpoint to which the logging events will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">
+            <summary>
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_client">
+            <summary>
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the 
+            logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">
+            <summary>
+            The encoding to use for the packet.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">
+            <summary>
+            Gets or sets the IP address of the remote host or multicast group to which
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            The IP address of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            <para>
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so
+            it is possible to use multicasts in an Internet scenario as long as your network provider 
+            supports multicasting.
+            </para>
+            <para>
+            Hosts that want to receive particular multicast messages must register their interest by joining
+            the multicast group.  Multicast messages are not sent to networks where no host has joined
+            the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
+            them from normal host addresses, allowing nodes to easily detect if a message is of interest.
+            </para>
+            <para>
+            Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>IP Address</term>
+                    <description>Description</description>
+                </listheader>
+                <item>
+                    <term>224.0.0.1</term>
+                    <description>
+                        <para>
+                        Sends a message to all system on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.2</term>
+                    <description>
+                        <para>
+                        Sends a message to all routers on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.12</term>
+                    <description>
+                        <para>
+                        The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            A complete list of actually reserved multicast addresses and their owners in the ranges
+            defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
+            </para>
+            <para>
+            The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
+            addresses.  These addresses can be reused with other local groups.  Routers are typically 
+            configured with filters to prevent multicast traffic in this range from flowing outside
+            of the local network.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemotePort">
+            <summary>
+            Gets or sets the TCP port number of the remote host or multicast group to which 
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will send messages to this TCP port number
+            on the remote host or multicast group.
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.LocalPort">
+            <summary>
+            Gets or sets the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </value>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will bind to this port for sending messages.
+            </para>
+            <para>
+            Setting the value to 0 (the default) will cause the udp client not to bind to
+            a local port.
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Client">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.UdpAppender"/> creates a <see cref="T:System.Net.Sockets.UdpClient"/> to send logging events 
+            over a network.  Classes deriving from <see cref="T:log4net.Appender.UdpAppender"/> can use this
+            property to get or set this <see cref="T:System.Net.Sockets.UdpClient"/>.  Use the underlying <see cref="T:System.Net.Sockets.UdpClient"/>
+            returned from <see cref="P:log4net.Appender.UdpAppender.Client"/> if you require access beyond that which 
+            <see cref="T:log4net.Appender.UdpAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteEndPoint">
+            <summary>
+            Gets or sets the cached remote endpoint to which the logging events should be sent.
+            </summary>
+            <value>
+            The cached remote endpoint to which the logging events will be sent.
+            </value>
+            <remarks>
+            The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method will initialize the remote endpoint 
+            with the values of the <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> and <see cref="P:log4net.Appender.UdpAppender.RemotePort"/>
+            properties.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.DefaultSyslogPort">
+            <summary>
+            Syslog port 514
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class is set up to write 
+            to a remote syslog daemon.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.AddMapping(log4net.Appender.RemoteSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity"/> mapping to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to syslog severity mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GeneratePriority(log4net.Appender.RemoteSyslogAppender.SyslogFacility,log4net.Appender.RemoteSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+            <remarks>
+            <para>
+            Generate a syslog priority.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The syslog severities.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facilities
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender">
+            <summary>
+            Delivers logging events to a remote logging sink. 
+            </summary>
+            <remarks>
+            <para>
+            This Appender is designed to deliver events to a remote sink. 
+            That is any object that implements the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface. It delivers the events using .NET remoting. The
+            object to deliver events to is specified by setting the
+            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.</para>
+            <para>
+            The RemotingAppender buffers events before sending them. This allows it to 
+            make more efficient use of the remoting infrastructure.</para>
+            <para>
+            Once the buffer is full the events are still not sent immediately. 
+            They are scheduled to be sent using a pool thread. The effect is that 
+            the send occurs asynchronously. This is very important for a 
+            number of non obvious reasons. The remoting infrastructure will 
+            flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.</para>
+            <para>
+            Because the events are sent asynchronously using pool threads it is possible to close 
+            this appender before all the queued events have been sent.
+            When closing the appender attempts to wait until all the queued events have been sent, but 
+            this will timeout after 30 seconds regardless.</para>
+            <para>
+            If this appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for. If the runtime terminates the threads before
+            the queued events have been sent then they will be lost. To ensure that all events
+            are sent the appender must be closed before the application exits. See 
+            <see cref="M:log4net.Core.LoggerManager.Shutdown"/> for details on how to shutdown
+            log4net programmatically.</para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemotingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            The events are not sent immediately. They are scheduled to be sent
+            using a pool thread. The effect is that the send occurs asynchronously.
+            This is very important for a number of non obvious reasons. The remoting
+            infrastructure will flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.
+            </remarks>
+            <param name="events">The events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.OnClose">
+            <summary>
+            Override base class close.
+            </summary>
+            <remarks>
+            <para>
+            This method waits while there are queued work items. The events are
+            sent asynchronously using <see cref="T:System.Threading.ThreadPool"/> work items. These items
+            will be sent once a thread pool thread is available to send them, therefore
+            it is possible to close the appender before all the queued events have been
+            sent.</para>
+            <para>
+            This method attempts to wait until all the queued events have been sent, but this 
+            method will timeout after 30 seconds regardless.</para>
+            <para>
+            If the appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.BeginAsyncSend">
+            <summary>
+            A work item is being queued into the thread pool
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.EndAsyncSend">
+            <summary>
+            A work item from the thread pool has completed
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBufferCallback(System.Object)">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            This method is designed to be used with the <see cref="T:System.Threading.ThreadPool"/>.
+            This method expects to be passed an array of <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the state param.
+            </remarks>
+            <param name="state">the logging events to send</param>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">
+            <summary>
+            The URL of the remote sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">
+            <summary>
+            The local proxy (.NET remoting) for the remote logging sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_queuedCallbackCount">
+            <summary>
+            The number of queued callbacks currently waiting or executing
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_workQueueEmptyEvent">
+            <summary>
+            Event used to signal when there are no queued work items
+            </summary>
+            <remarks>
+            This event is set when there are no queued work items. In this
+            state it is safe to close the appender.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemotingAppender.Sink">
+            <summary>
+            Gets or sets the URL of the well-known object that will accept 
+            the logging events.
+            </summary>
+            <value>
+            The well-known URL of the remote sink.
+            </value>
+            <remarks>
+            <para>
+            The URL of the remoting sink that will accept logging events.
+            The sink must implement the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink">
+            <summary>
+            Interface used to deliver <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            This interface must be implemented by a remoting sink
+            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used
+            to deliver logging events to the sink.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.IRemoteLoggingSink.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Delivers logging events to the remote sink
+            </summary>
+            <param name="events">Array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers logging events to the remote sink
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender">
+            <summary>
+            Appender that rolls log files based on size or date or both.
+            </summary>
+            <remarks>
+            <para>
+            RollingFileAppender can roll log files based on size or date or both
+            depending on the setting of the <see cref="P:log4net.Appender.RollingFileAppender.RollingStyle"/> property.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Size"/> the log file will be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Date"/> the log file will be rolled
+            once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/> the log file will be
+            rolled once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed, but within a date boundary the file will also be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> the log file will be rolled when
+            the appender is configured. This effectively means that the log file can be
+            rolled once per program execution.
+            </para>
+            <para>
+            A of few additional optional features have been added:
+            <list type="bullet">
+            <item>Attach date pattern for current log file <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/></item>
+            <item>Backup number increments for newer files <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/></item>
+            <item>Infinite number of backups by file size <see cref="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups"/></item>
+            </list>
+            </para>
+            
+            <note>
+            <para>
+            For large or infinite numbers of backup files a <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> 
+            greater than zero is highly recommended, otherwise all the backup files need
+            to be renamed each time a new backup is created.
+            </para>
+            <para>
+            When Date/Time based rolling is used setting <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> 
+            to <see langword="true"/> will reduce the number of file renamings to few or none.
+            </para>
+            </note>
+            
+            <note type="caution">
+            <para>
+            Changing <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> or <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> without clearing
+            the log file directory of backup files will cause unexpected and unwanted side effects.  
+            </para>
+            </note>
+            
+            <para>
+            If Date/Time based rolling is enabled this appender will attempt to roll existing files
+            in the directory without a Date/Time tag based on the last write date of the base log file.
+            The appender only rolls the log file when a message is logged. If Date/Time based rolling 
+            is enabled then the appender will not roll the log file at the Date/Time boundary but
+            at the point when the next message is logged after the boundary has been crossed.
+            </para>
+            
+            <para>
+            The <see cref="T:log4net.Appender.RollingFileAppender"/> extends the <see cref="T:log4net.Appender.FileAppender"/> and
+            has the same behavior when opening the log file.
+            The appender will first try to open the file for writing when <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            When rolling a backup file necessitates deleting an older backup file the
+            file to be deleted is moved to a temporary name before being deleted.
+            </para>
+            
+            <note type="caution">
+            <para>
+            A maximum number of backup files when rolling on date/time boundaries is not supported.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Edward Smit</author>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RollingFileAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Finalize">
+            <summary>
+            Cleans up all resources used by this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.declaringType">
+            <summary>
+            The fully qualified type of the RollingFileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <remarks>
+            This method can be overridden by sub classes.
+            </remarks>
+            <param name="writer">the writer to set</param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write out a logging event.
+            </summary>
+            <param name="loggingEvent">the event to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Write out an array of logging events.
+            </summary>
+            <param name="loggingEvents">the events to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.AdjustFileBeforeAppend">
+            <summary>
+            Performs any required rolling before outputting the next event
+            </summary>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Creates and opens the file for logging.  If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/>
+            is false then the fully qualified name is determined and used.
+            </summary>
+            <param name="fileName">the name of the file to open</param>
+            <param name="append">true to append to existing file</param>
+            <remarks>
+            <para>This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetNextOutputFileName(System.String)">
+            <summary>
+            Get the current output file name
+            </summary>
+            <param name="fileName">the base file name</param>
+            <returns>the output file name</returns>
+            <remarks>
+            The output file name is based on the base fileName specified.
+            If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> is set then the output 
+            file name is the same as the base file passed in. Otherwise
+            the output file depends on the date pattern, on the count
+            direction or both.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DetermineCurSizeRollBackups">
+            <summary>
+            Determines curSizeRollBackups (only within the current roll point)
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">
+            <summary>
+            Generates a wildcard pattern that can be used to find all files
+            that are similar to the base file name.
+            </summary>
+            <param name="baseFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">
+            <summary>
+            Builds a list of filenames for all files matching the base filename plus a file
+            pattern.
+            </summary>
+            <param name="baseFilePath"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">
+            <summary>
+            Initiates a roll over if needed for crossing a date boundary since the last run.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">
+            <summary>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            </summary>
+            <remarks>
+            <para>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            The following is done
+            <list type="bullet">
+            <item>determine curSizeRollBackups (only within the current roll point)</item>
+            <item>initiates a roll over if needed for crossing a date boundary since the last run.</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">
+            <summary>
+            Does the work of bumping the 'current' file counter higher
+            to the highest count when an incremental file name is seen.
+            The highest count is either the first file (when count direction
+            is greater than 0) or the last file (when count direction less than 0).
+            In either case, we want to know the highest count that is present.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="curFileName"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetBackUpIndex(System.String)">
+            <summary>
+            Attempts to extract a number from the end of the file name that indicates
+            the number of the times the file has been rolled over.
+            </summary>
+            <remarks>
+            Certain date pattern extensions like yyyyMMdd will be parsed as valid backup indexes.
+            </remarks>
+            <param name="curFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">
+            <summary>
+            Takes a list of files and a base file name, and looks for 
+            'incremented' versions of the base file.  Bumps the max
+            count up to the highest count seen.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="arrayFiles"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod(System.String)">
+            <summary>
+            Calculates the RollPoint for the datePattern supplied.
+            </summary>
+            <param name="datePattern">the date pattern to calculate the check period for</param>
+            <returns>The RollPoint that is most accurate for the date pattern supplied</returns>
+            <remarks>
+            Essentially the date pattern is examined to determine what the
+            most suitable roll point is. The roll point chosen is the roll point
+            with the smallest period that can be detected using the date pattern
+            supplied. i.e. if the date pattern only outputs the year, month, day 
+            and hour then the smallest roll point that can be detected would be
+            and hourly roll point as minutes could not be detected.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Sets initial conditions including date/time roll over information, first check,
+            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize
+            the current number of backups.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.CombinePath(System.String,System.String)">
+            <summary>
+            
+            </summary>
+            <param name="path1"></param>
+            <param name="path2">.1, .2, .3, etc.</param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime(System.Boolean)">
+            <summary>
+            Rollover the file(s) to date/time tagged file(s).
+            </summary>
+            <param name="fileIsOpen">set to true if the file to be rolled is currently open</param>
+            <remarks>
+            <para>
+            Rollover the file(s) to date/time tagged file(s).
+            Resets curSizeRollBackups. 
+            If fileIsOpen is set then the new file is opened (through SafeOpenFile).
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">
+            <summary>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>.
+            </summary>
+            <param name="fromFile">Name of existing file to roll.</param>
+            <param name="toFile">New name for file.</param>
+            <remarks>
+            <para>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. It
+            also checks for existence of target file and deletes if it does.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.FileExists(System.String)">
+            <summary>
+            Test if a file exists at a specified path
+            </summary>
+            <param name="path">the path to the file</param>
+            <returns>true if the file exists</returns>
+            <remarks>
+            <para>
+            Test if a file exists at a specified path
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">
+            <summary>
+            Deletes the specified file if it exists.
+            </summary>
+            <param name="fileName">The file to delete.</param>
+            <remarks>
+            <para>
+            Delete a file if is exists.
+            The file is first moved to a new filename then deleted.
+            This allows the file to be removed even when it cannot
+            be deleted, but it still can be moved.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">
+            <summary>
+            Implements file roll base on file size.
+            </summary>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. Moreover, <c>File</c> is
+            renamed <c>File.1</c> and closed.
+            </para>
+            <para>
+            A new file is created to receive further log output.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverRenameFiles(System.String)">
+            <summary>
+            Implements file roll.
+            </summary>
+            <param name="baseFileName">the base name to rename</param>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. 
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            <para>
+            This is called by <see cref="M:log4net.Appender.RollingFileAppender.RollOverSize"/> to rename the files.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">
+            <summary>
+            Get the start time of the next window for the current rollpoint
+            </summary>
+            <param name="currentDateTime">the current date</param>
+            <param name="rollPoint">the type of roll point we are working with</param>
+            <returns>the start time for the next roll point an interval after the currentDateTime date</returns>
+            <remarks>
+            <para>
+            Returns the date of the next roll point after the currentDateTime date passed to the method.
+            </para>
+            <para>
+            The basic strategy is to subtract the time parts that are less significant
+            than the rollpoint from the current time. This should roll the time back to
+            the start of the time window for the current rollpoint. Then we add 1 window
+            worth of time and get the start time of the next window for the rollpoint.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">
+            <summary>
+            This object supplies the current date/time.  Allows test code to plug in
+            a method to control this class when testing date/time based rolling. The default
+            implementation uses the underlying value of DateTime.Now.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">
+            <summary>
+            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> 
+            meaning daily rollover.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">
+            <summary>
+            The actual formatted filename that is currently being written to
+            or will be the file transferred to on roll over
+            (based on staticLogFileName).
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">
+            <summary>
+            The timestamp when we shall next recompute the filename.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_now">
+            <summary>
+            Holds date of last roll over
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">
+            <summary>
+            The type of rolling done
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">
+            <summary>
+            The default maximum file size is 10MB
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">
+            <summary>
+            There is zero backup files by default
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">
+            <summary>
+            How many sized based backups have been made so far
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">
+            <summary>
+            The rolling file count direction. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">
+            <summary>
+            The rolling mode used in this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">
+            <summary>
+            Cache flag set if we are rolling by date.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">
+            <summary>
+            Cache flag set if we are rolling by size.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">
+            <summary>
+            Value indicating whether to always log to the same file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_preserveLogFileNameExtension">
+            <summary>
+            Value indicating whether to preserve the file name extension when rolling.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">
+            <summary>
+            FileName provided in configuration.  Used for rolling properly
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_mutexForRolling">
+            <summary>
+            A mutex that is used to lock rolling of files.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DateTimeStrategy">
+            <summary>
+            Gets or sets the strategy for determining the current date and time. The default
+            implementation is to use LocalDateTime which internally calls through to DateTime.Now. 
+            DateTime.UtcNow may be used on frameworks newer than .NET 1.0 by specifying
+            <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </summary>
+            <value>
+            An implementation of the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> interface which returns the current date and time.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> used to return the current date and time.
+            </para>
+            <para>
+            There are two built strategies for determining the current date and time, 
+            <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>
+            and <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </para>
+            <para>
+            The default strategy is <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">
+            <summary>
+            Gets or sets the date pattern to be used for generating file names
+            when rolling over on date.
+            </summary>
+            <value>
+            The date pattern to be used for generating file names when rolling 
+            over on date.
+            </value>
+            <remarks>
+            <para>
+            Takes a string in the same format as expected by 
+            <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.
+            </para>
+            <para>
+            This property determines the rollover schedule when rolling over
+            on date.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">
+            <summary>
+            Gets or sets the maximum number of backup files that are kept before
+            the oldest is erased.
+            </summary>
+            <value>
+            The maximum number of backup files that are kept before the oldest is
+            erased.
+            </value>
+            <remarks>
+            <para>
+            If set to zero, then there will be no backup files and the log file 
+            will be truncated when it reaches <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  
+            </para>
+            <para>
+            If a negative number is supplied then no deletions will be made.  Note 
+            that this could result in very slow performance as a large number of 
+            files are rolled over unless <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> is used.
+            </para>
+            <para>
+            The maximum applies to <b>each</b> time based group of files and 
+            <b>not</b> the total.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size in bytes that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except
+            that it is required for differentiating the setter taking a
+            <see cref="T:System.Int64"/> argument from the setter taking a <see cref="T:System.String"/> 
+            argument.
+            </para>
+            <para>
+            The default maximum file size is 10MB (10*1024*1024).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property allows you to specify the maximum size with the
+            suffixes "KB", "MB" or "GB" so that the size is interpreted being 
+            expressed respectively in kilobytes, megabytes or gigabytes. 
+            </para>
+            <para>
+            For example, the value "10KB" will be interpreted as 10240 bytes.
+            </para>
+            <para>
+            The default maximum file size is 10MB.
+            </para>
+            <para>
+            If you have the option to set the maximum file size programmatically
+            consider using the <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/> property instead as this
+            allows you to set the size in bytes as a <see cref="T:System.Int64"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">
+            <summary>
+            Gets or sets the rolling file count direction. 
+            </summary>
+            <value>
+            The rolling file count direction.
+            </value>
+            <remarks>
+            <para>
+            Indicates if the current file is the lowest numbered file or the
+            highest numbered file.
+            </para>
+            <para>
+            By default newer files have lower numbers (<see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &lt; 0),
+            i.e. log.1 is most recent, log.5 is the 5th backup, etc...
+            </para>
+            <para>
+            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 does the opposite i.e.
+            log.1 is the first backup made, log.5 is the 5th backup made, etc.
+            For infinite backups use <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 to reduce 
+            rollover costs.
+            </para>
+            <para>The default file count direction is -1.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">
+            <summary>
+            Gets or sets the rolling style.
+            </summary>
+            <value>The rolling style.</value>
+            <remarks>
+            <para>
+            The default rolling style is <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/>.
+            </para>
+            <para>
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> this appender's
+            <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is set to <c>false</c>, otherwise
+            the appender would append to a single file rather than rolling
+            the file each time it is opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.PreserveLogFileNameExtension">
+            <summary>
+            Gets or sets a value indicating whether to preserve the file name extension when rolling.
+            </summary>
+            <value>
+            <c>true</c> if the file name extension should be preserved.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is rolled to file.log.yyyy-MM-dd or file.log.curSizeRollBackup.
+            However, under Windows the new file name will loose any program associations as the
+            extension is changed. Optionally file.log can be renamed to file.yyyy-MM-dd.log or
+            file.curSizeRollBackup.log to maintain any program associations.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">
+            <summary>
+            Gets or sets a value indicating whether to always log to
+            the same file.
+            </summary>
+            <value>
+            <c>true</c> if always should be logged to the same file, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is always the current file.  Optionally
+            file.log.yyyy-mm-dd for current formatted datePattern can by the currently
+            logging file (or file.log.curSizeRollBackup or even
+            file.log.yyyy-mm-dd.curSizeRollBackup).
+            </para>
+            <para>
+            This will make time based rollovers with a large number of backups 
+            much faster as the appender it won't have to rename all the backups!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">
+            <summary>
+            Style of rolling to use
+            </summary>
+            <remarks>
+            <para>
+            Style of rolling to use
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Once">
+            <summary>
+            Roll files once per program execution
+            </summary>
+            <remarks>
+            <para>
+            Roll files once per program execution.
+            Well really once each time this appender is
+            configured.
+            </para>
+            <para>
+            Setting this option also sets <c>AppendToFile</c> to
+            <c>false</c> on the <c>RollingFileAppender</c>, otherwise
+            this appender would just be a normal file appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">
+            <summary>
+            Roll files based only on the size of the file
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">
+            <summary>
+            Roll files based only on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">
+            <summary>
+            Roll files based on both the size and date of the file
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">
+            <summary>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </summary>
+            <remarks>
+            <para>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.InvalidRollPoint">
+            <summary>
+            Roll the log not based on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMinute">
+            <summary>
+            Roll the log for each minute
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfHour">
+            <summary>
+            Roll the log for each hour
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HalfDay">
+            <summary>
+            Roll the log twice a day (midday and midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfDay">
+            <summary>
+            Roll the log each day (midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfWeek">
+            <summary>
+            Roll the log each week
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMonth">
+            <summary>
+            Roll the log each month
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.IDateTime">
+            <summary>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            </summary>
+            <remarks>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            Used primarily to allow test classes to plug themselves in so they can
+            supply test date/times.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.IDateTime.Now">
+            <summary>
+            Gets the <i>current</i> time.
+            </summary>
+            <value>The <i>current</i> time.</value>
+            <remarks>
+            <para>
+            Gets the <i>current</i> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.LocalDateTime">
+            <summary>
+            Default implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.LocalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.UniversalDateTime">
+            <summary>
+            Implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time as the coordinated universal time (UTC).
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.UniversalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender">
+            <summary>
+            Send an e-mail when a specific logging event occurs, typically on errors 
+            or fatal errors.
+            </summary>
+            <remarks>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            <note type="caution">
+            Authentication and setting the server Port are only available on the MS .NET 1.1 runtime.
+            For these features to be enabled you need to ensure that you are using a version of
+            the log4net assembly that is built against the MS .NET 1.1 framework and that you are
+            running the your application on the MS .NET 1.1 runtime. On all other platforms only sending
+            unauthenticated messages to a server listening on port 25 (the default) is supported.
+            </note>
+            <para>
+            Authentication is supported by setting the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property to
+            either <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> or <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>.
+            If using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> authentication then the <see cref="P:log4net.Appender.SmtpAppender.Username"/>
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> properties must also be set.
+            </para>
+            <para>
+            To set the SMTP server port use the <see cref="P:log4net.Appender.SmtpAppender.Port"/> property. The default port is 25.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendEmail(System.String)">
+            <summary>
+            Send the email message
+            </summary>
+            <param name="messageBody">the body text to include in the mail</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.MaybeTrimSeparators(System.String)">
+            <summary>
+              trims leading and trailing commas or semicolons
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.To">
+            <summary>
+            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).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Cc">
+            <summary>
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses 
+            that will be carbon copied (use semicolon on .NET 1.1 and comma for later versions).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Bcc">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses
+            that will be blind carbon copied.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of recipient e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SmtpHost">
+            <summary>
+            Gets or sets the name of the SMTP relay mail server to use to send 
+            the e-mail messages.
+            </summary>
+            <value>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </value>
+            <remarks>
+            <para>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.LocationInfo">
+            <summary>
+            Obsolete
+            </summary>
+            <remarks>
+            Use the BufferingAppenderSkeleton Fix methods instead 
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Authentication">
+            <summary>
+            The mode to use to authentication with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            Valid Authentication mode values are: <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>, 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, and <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>. 
+            The default value is <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>. When using 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> you must specify the <see cref="P:log4net.Appender.SmtpAppender.Username"/> 
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> to use to authenticate.
+            When using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/> the Windows credentials for the current
+            thread, if impersonating, or the process will be used to authenticate. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Username">
+            <summary>
+            The username to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the username will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Password">
+            <summary>
+            The password to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the password will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Port">
+            <summary>
+            The port on which the SMTP server is listening
+            </summary>
+            <remarks>
+            <note type="caution">Server Port is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            The port on which the SMTP server is listening. The default
+            port is <c>25</c>. The Port can only be changed when running on
+            the MS .NET 1.1 runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Priority">
+            <summary>
+            Gets or sets the priority of the e-mail message
+            </summary>
+            <value>
+            One of the <see cref="T:System.Net.Mail.MailPriority"/> values.
+            </value>
+            <remarks>
+            <para>
+            Sets the priority of the e-mails generated by this
+            appender. The default priority is <see cref="F:System.Net.Mail.MailPriority.Normal"/>.
+            </para>
+            <para>
+            If you are using this appender to report errors then
+            you may want to set the priority to <see cref="F:System.Net.Mail.MailPriority.High"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.EnableSsl">
+            <summary>
+            Enable or disable use of SSL when sending e-mail message
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.ReplyTo">
+            <summary>
+            Gets or sets the reply-to e-mail address.
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SubjectEncoding">
+            <summary>
+            Gets or sets the subject encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.BodyEncoding">
+            <summary>
+            Gets or sets the body encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender.SmtpAuthentication">
+            <summary>
+            Values for the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property.
+            </summary>
+            <remarks>
+            <para>
+            SMTP authentication modes.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None">
+            <summary>
+            No authentication
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic">
+            <summary>
+            Basic authentication.
+            </summary>
+            <remarks>
+            Requires a username and password to be supplied
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm">
+            <summary>
+            Integrated authentication
+            </summary>
+            <remarks>
+            Uses the Windows credentials from the current thread or process to authenticate.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpPickupDirAppender">
+            <summary>
+            Send an email when a specific logging event occurs, typically on errors 
+            or fatal errors. Rather than sending via smtp it writes a file into the
+            directory specified by <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>. This allows services such
+            as the IIS SMTP agent to manage sending the messages.
+            </summary>
+            <remarks>
+            <para>
+            The configuration for this appender is identical to that of the <c>SMTPAppender</c>,
+            except that instead of specifying the <c>SMTPAppender.SMTPHost</c> you specify
+            <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>.
+            </para>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpPickupDirAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            </remarks>
+            <author>Niall Daley</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+            <remarks>
+            <para>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions">
+            <summary>
+            Activate the options on this appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpPickupDirAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.To">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.PickupDir">
+            <summary>
+            Gets or sets the path to write the messages to.
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the path to write the messages to. This should be the same
+            as that used by the agent sending the messages.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.FileExtension">
+            <summary>
+            Gets or sets the file extension for the generated files
+            </summary>
+            <value>
+            The file extension for the generated files
+            </value>
+            <remarks>
+            <para>
+            The file extension for the generated files
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender">
+            <summary>
+            Appender that allows clients to connect via Telnet to receive log messages
+            </summary>
+            <remarks>	
+            <para>
+            The TelnetAppender accepts socket connections and streams logging messages
+            back to the client.  
+            The output is provided in a telnet-friendly way so that a log can be monitored 
+            over a TCP/IP socket.
+            This allows simple remote monitoring of application logging.
+            </para>
+            <para>
+            The default <see cref="P:log4net.Appender.TelnetAppender.Port"/> is 23 (the telnet port).
+            </para>
+            </remarks>
+            <author>Keith Long</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TelnetAppender.declaringType">
+            <summary>
+            The fully qualified type of the TelnetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.OnClose">
+            <summary>
+            Overrides the parent method to close the socket handler
+            </summary>
+            <remarks>
+            <para>
+            Closes all the outstanding connections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Create the socket handler and wait for connections
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to each connected client.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to each connected client.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.Port">
+            <summary>
+            Gets or sets the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </value>
+            <remarks>
+            <para>
+            The default value is 23 (the telnet port).
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler">
+            <summary>
+            Helper class to manage connected clients
+            </summary>
+            <remarks>
+            <para>
+            The SocketHandler class is used to accept connections from
+            clients.  It is threaded so that clients can connect/disconnect
+            asynchronously.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.#ctor(System.Int32)">
+            <summary>
+            Opens a new server port on <paramref ref="port"/>
+            </summary>
+            <param name="port">the local port to listen on for connections</param>
+            <remarks>
+            <para>
+            Creates a socket handler on the specified local server port.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Send(System.String)">
+            <summary>
+            Sends a string message to each of the connected clients
+            </summary>
+            <param name="message">the text to send</param>
+            <remarks>
+            <para>
+            Sends a string message to each of the connected clients
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.AddClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Add a client to the internal clients list
+            </summary>
+            <param name="client">client to add</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.RemoveClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Remove a client from the internal clients list
+            </summary>
+            <param name="client">client to remove</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.OnConnect(System.IAsyncResult)">
+            <summary>
+            Callback used to accept a connection on the server socket
+            </summary>
+            <param name="asyncResult">The result of the asynchronous operation</param>
+            <remarks>
+            <para>
+            On connection adds to the list of connections 
+            if there are two many open connections you will be disconnected
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Dispose">
+            <summary>
+            Close all network connections
+            </summary>
+            <remarks>
+            <para>
+            Make sure we close all network connections
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.SocketHandler.HasConnections">
+            <summary>
+            Test if this handler has active connections
+            </summary>
+            <value>
+            <c>true</c> if this handler has active connections
+            </value>
+            <remarks>
+            <para>
+            This property will be <c>true</c> while this handler has
+            active connections, that is at least one connection that 
+            the handler will attempt to send a message to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient">
+            <summary>
+            Class that represents a client connected to this handler
+            </summary>
+            <remarks>
+            <para>
+            Class that represents a client connected to this handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.#ctor(System.Net.Sockets.Socket)">
+            <summary>
+            Create this <see cref="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient"/> for the specified <see cref="T:System.Net.Sockets.Socket"/>
+            </summary>
+            <param name="socket">the client's socket</param>
+            <remarks>
+            <para>
+            Opens a stream writer on the socket.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Send(System.String)">
+            <summary>
+            Write a string to the client
+            </summary>
+            <param name="message">string to send</param>
+            <remarks>
+            <para>
+            Write a string to the client
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Dispose">
+            <summary>
+            Cleanup the clients connection
+            </summary>
+            <remarks>
+            <para>
+            Close the socket connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TraceAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Trace"/> class for details on configuring the
+            trace system.
+            </para>
+            <para>
+            Events are written using the <c>System.Diagnostics.Trace.Write(string,string)</c>
+            method. The event's logger name is the default value for the category parameter 
+            of the Write method. 
+            </para>
+            <para>
+            <b>Compact Framework</b><br/>
+            The Compact Framework does not support the <see cref="T:System.Diagnostics.Trace"/>
+            class for any operation except <c>Assert</c>. When using the Compact Framework this
+            appender will write to the <see cref="T:System.Diagnostics.Debug"/> system rather than
+            the Trace system. This appender will therefore behave like the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </para>
+            </remarks>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.AliasDomainAttribute">
+            <summary>
+            Assembly level attribute that specifies a domain to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.DomainAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's domain to its repository by
+            specifying this attribute with the name of the target domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required domains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.AliasRepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies a repository to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.RepositoryAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's repository to its repository by
+            specifying this attribute with the name of the target repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required repositories.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.AliasRepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </summary>
+            <param name="name">The repository to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.AliasRepositoryAttribute.Name">
+            <summary>
+            Gets or sets the repository to alias to this assemby's repository.
+            </summary>
+            <value>
+            The repository to alias to this assemby's repository.
+            </value>
+            <remarks>
+            <para>
+            The name of the repository to alias to this assemby's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.AliasDomainAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasDomainAttribute"/> class with 
+            the specified domain to alias to this assembly's repository.
+            </summary>
+            <param name="name">The domain to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Obsolete. Use <see cref="T:log4net.Config.AliasRepositoryAttribute"/> instead of <see cref="T:log4net.Config.AliasDomainAttribute"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.BasicConfigurator">
+            <summary>
+            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </summary>
+            <remarks>
+            <para>
+            Allows very simple programmatic configuration of log4net.
+            </para>
+            <para>
+            Only one appender can be configured using this configurator.
+            The appender is set at the root of the hierarchy and all logging
+            events will be delivered to that appender.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Config.BasicConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the BasicConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.BasicConfigurator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure">
+            <summary>
+            Initializes the log4net system with a default configuration.
+            </summary>
+            <remarks>
+            <para>
+            Initializes the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the log4net system using the specified appenders.
+            </summary>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initializes the log4net system using the specified appender.
+            </summary>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> with a default configuration.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Initializes the specified repository using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appenders.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.ConfiguratorAttribute">
+            <summary>
+            Base class for all log4net configuration attributes.
+            </summary>
+            <remarks>
+            This is an abstract class that must be extended by 
+            specific configurators. This attribute allows the
+            configurator to be parameterized by an assembly level
+            attribute.
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">
+            <summary>
+            Constructor used by subclasses.
+            </summary>
+            <param name="priority">the ordering priority for this configurator</param>
+            <remarks>
+            <para>
+            The <paramref name="priority"/> is used to order the configurator
+            attributes before they are invoked. Higher priority configurators are executed
+            before lower priority ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Abstract method implemented by a subclass. When this method is called
+            the subclass should configure the <paramref name="targetRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">
+            <summary>
+            Compare this instance to another ConfiguratorAttribute
+            </summary>
+            <param name="obj">the object to compare to</param>
+            <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>
+            <remarks>
+            <para>
+            Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.
+            Sorts by priority in descending order. Objects with the same priority are
+            randomly ordered.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DomainAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging domain for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            <b>DomainAttribute is obsolete. Use RepositoryAttribute instead of DomainAttribute.</b>
+            </para>
+            <para>
+            Assemblies are mapped to logging domains. Each domain has its own
+            logging repository. This attribute specified on the assembly controls
+            the configuration of the domain. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the repository objects to create for the domain. If 
+            this attribute is not specified and a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> is not specified
+            then the assembly will be part of the default shared logging domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.RepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging repository for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            Assemblies are mapped to logging repository. This attribute specified 
+            on the assembly controls
+            the configuration of the repository. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the repository that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the <see cref="T:log4net.Repository.ILoggerRepository"/> object 
+            to create for the assembly. If this attribute is not specified or a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> 
+            is not specified then the assembly will be part of the default shared logging repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class 
+            with the name of the repository.
+            </summary>
+            <param name="name">The name of the repository.</param>
+            <remarks>
+            <para>
+            Initialize the attribute with the name for the assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.Name">
+            <summary>
+            Gets or sets the name of the logging repository.
+            </summary>
+            <value>
+            The string name to use as the name of the repository associated with this
+            assembly.
+            </value>
+            <remarks>
+            <para>
+            This value does not have to be unique. Several assemblies can share the
+            same repository. They will share the logging configuration of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.RepositoryType">
+            <summary>
+            Gets or sets the type of repository to create for this assembly.
+            </summary>
+            <value>
+            The type of repository to create for this assembly.
+            </value>
+            <remarks>
+            <para>
+            The type of the repository to create for the assembly.
+            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            interface.
+            </para>
+            <para>
+            This will be the type of repository created when 
+            the repository is created. If multiple assemblies reference the
+            same repository then the repository is only created once using the
+            <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/> of the first assembly to call into the 
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class 
+            with the name of the domain.
+            </summary>
+            <param name="name">The name of the domain.</param>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DOMConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="T:log4net.Config.DOMConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.XmlConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            <para>
+            If neither of the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>
+            properties are set the configuration is loaded from the application's .config file.
+            If set the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property takes priority over the
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property. The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property
+            specifies a path to a file to load the config from. The path is relative to the
+            application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property is used as a postfix to the assembly file name.
+            The config file must be located in the  application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            For example in a console application setting the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> to
+            <c>config</c> has the same effect as not specifying the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or 
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> properties.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.Watch"/> property can be set to cause the <see cref="T:log4net.Config.XmlConfigurator"/>
+            to watch the configuration file for changes.
+            </para>
+            <note>
+            <para>
+            Log4net will only look for assembly level configuration attributes once.
+            When using the log4net assembly level attributes to control the configuration 
+            of log4net you must ensure that the first call to any of the 
+            <see cref="T:log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration
+            attributes. 
+            </para>
+            <para>
+            If you cannot guarantee the order in which log4net calls will be made from 
+            different assemblies you must use programmatic configuration instead, i.e.
+            call the <see cref="M:XmlConfigurator.Configure()"/> method directly.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Configure the repository using the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            The <paramref name="targetRepository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>
+            class otherwise the <see cref="T:log4net.Config.XmlConfigurator"/> will not be able to
+            configure it.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="targetRepository"/> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.</exception>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from the local file system
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configure the specified repository using a <see cref="T:System.IO.FileInfo"/>
+            </summary>
+            <param name="targetRepository">The repository to configure.</param>
+            <param name="configFile">the FileInfo pointing to the config file</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromUri(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from a URI
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="F:log4net.Config.XmlConfiguratorAttribute.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfiguratorAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile">
+            <summary>
+            Gets or sets the filename of the configuration file.
+            </summary>
+            <value>
+            The filename of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified, this is the name of the configuration file to use with
+            the <see cref="T:log4net.Config.XmlConfigurator"/>. This file path is relative to the
+            <b>application base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>).
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension">
+            <summary>
+            Gets or sets the extension of the configuration file.
+            </summary>
+            <value>
+            The extension of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified this is the extension for the configuration file.
+            The path to the config file is built by using the <b>application 
+            base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>),
+            the <b>assembly file name</b> and the config file extension.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> is set to <c>MyExt</c> then
+            possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or
+            <c>MyClassLibrary.dll.MyExt</c>.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.Watch">
+            <summary>
+            Gets or sets a value indicating whether to watch the configuration file.
+            </summary>
+            <value>
+            <c>true</c> if the configuration should be watched, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            If this flag is specified and set to <c>true</c> then the framework
+            will watch the configuration file and will reload the config each time 
+            the file is modified.
+            </para>
+            <para>
+            The config file can only be watched if it is loaded from local disk.
+            In a No-Touch (Smart Client) deployment where the application is downloaded
+            from a web server the config file may not reside on the local disk
+            and therefore it may not be able to watch it.
+            </para>
+            <note>
+            Watching configuration is not supported on the SSCLI.
+            </note>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
+            <summary>
+            Class to register for the log4net section of the configuration file
+            </summary>
+            <remarks>
+            The log4net section of the configuration file needs to have a section
+            handler registered. This is the section handler used. It simply returns
+            the XML element that is the root of the section.
+            </remarks>
+            <example>
+            Example of registering the log4net section handler :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<configSections>
+            		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
+            	</configSections>
+            	<log4net>
+            		log4net configuration XML goes here
+            	</log4net>
+            </configuration>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
+            <summary>
+            Parses the configuration section.
+            </summary>
+            <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
+            <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>
+            <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>
+            <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.PluginAttribute">
+            <summary>
+            Assembly level attribute that specifies a plugin to attach to 
+            the repository.
+            </summary>
+            <remarks>
+            <para>
+            Specifies the type of a plugin to create and attach to the
+            assembly's repository. The plugin type must implement the
+            <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Plugin.IPluginFactory">
+            <summary>
+            Interface used to create plugins.
+            </summary>
+            <remarks>
+            <para>
+            Interface used to create  a plugin.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPluginFactory.CreatePlugin">
+            <summary>
+            Creates the plugin object.
+            </summary>
+            <returns>the new plugin instance</returns>
+            <remarks>
+            <para>
+            Create and return a new plugin instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="typeName">The type name of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            <para>
+            Where possible use the constructor that takes a <see cref="T:System.Type"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.Type)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="type">The type of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.CreatePlugin">
+            <summary>
+            Creates the plugin object defined by this attribute.
+            </summary>
+            <remarks>
+            <para>
+            Creates the instance of the <see cref="T:log4net.Plugin.IPlugin"/> object as 
+            specified by this attribute.
+            </para>
+            </remarks>
+            <returns>The plugin object.</returns>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.ToString">
+            <summary>
+            Returns a representation of the properties of this object.
+            </summary>
+            <remarks>
+            <para>
+            Overrides base class <see cref="M:Object.ToString()" /> method to 
+            return a representation of the properties of this object.
+            </para>
+            </remarks>
+            <returns>A representation of the properties of this object</returns>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.Type">
+            <summary>
+            Gets or sets the type for the plugin.
+            </summary>
+            <value>
+            The type for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type for the plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.TypeName">
+            <summary>
+            Gets or sets the type name for the plugin.
+            </summary>
+            <value>
+            The type name for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type name for the plugin.
+            </para>
+            <para>
+            Where possible use the <see cref="P:log4net.Config.PluginAttribute.Type"/> property instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.SecurityContextProviderAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">
+            <summary>
+            Construct provider attribute with type specified
+            </summary>
+            <param name="providerType">the type of the provider to use</param>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the SecurityContextProvider
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.
+            Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.SecurityContextProviderAttribute.declaringType">
+            <summary>
+            The fully qualified type of the SecurityContextProviderAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">
+            <summary>
+            Gets or sets the type of the provider to use.
+            </summary>
+            <value>
+            the type of the provider to use.
+            </value>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Uri)">
+            <summary>
+            Configures log4net using the specified configuration URI.
+            </summary>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration data stream.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Uri)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            URI.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.InternalConfigureFromXml(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the specified repository using a <c>log4net</c> element.
+            </summary>
+            <param name="repository">The hierarchy to configure.</param>
+            <param name="element">The element to parse.</param>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            <para>
+            This method is ultimately called by one of the Configure methods 
+            to load the configuration from an <see cref="T:System.Xml.XmlElement"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.m_repositoryName2ConfigAndWatchHandler">
+            <summary>
+            Maps repository names to ConfigAndWatchHandler instances to allow a particular
+            ConfigAndWatchHandler to dispose of its FileSystemWatcher when a repository is 
+            reconfigured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler">
+            <summary>
+            Class used to watch config files.
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="T:System.IO.FileSystemWatcher"/> to monitor
+            changes to a specified file. Because multiple change notifications
+            may be raised when the file is modified, a timer is used to
+            compress the notifications into a single event. The timer
+            waits for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> time before delivering
+            the event notification. If any further <see cref="T:System.IO.FileSystemWatcher"/>
+            change notifications arrive while the timer is waiting it
+            is reset and waits again for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> to
+            elapse.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis">
+            <summary>
+            The default amount of time to wait after receiving notification
+            before reloading the config file.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_configFile">
+            <summary>
+            Holds the FileInfo used to configure the XmlConfigurator
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_repository">
+            <summary>
+            Holds the repository being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_timer">
+            <summary>
+            The timer used to compress the notification events.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_watcher">
+            <summary>
+            Watches file for changes. This object should be disposed when no longer
+            needed to free system handles on the watched resources.
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class to
+            watch a specified config file used to configure a repository.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The configuration file to watch.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.OnWatchedFileChange(System.Object)">
+            <summary>
+            Called by the timer when the configuration has been updated.
+            </summary>
+            <param name="state">null</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.Dispose">
+            <summary>
+            Release the handles held by the watcher and timer.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.CompactRepositorySelector">
+            <summary>
+            The implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface suitable
+            for use with the compact framework
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.IRepositorySelector"/> implementation is a simple
+            mapping between repository name and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            object.
+            </para>
+            <para>
+            The .NET Compact Framework 1.0 does not support retrieving assembly
+            level attributes therefore unlike the <c>DefaultRepositorySelector</c>
+            this selector does not examine the calling assembly for attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Core.IRepositorySelector">
+            <summary>
+            Interface used by the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.Core.IRepositorySelector"/> 
+            to specify the policy for selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> 
+            to return to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association. The results of this method must be repeatable, i.e.
+            when called again with the same arguments the result must be the
+            save value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the named <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repositoryName">The name to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            Lookup a named <see cref="T:log4net.Repository.ILoggerRepository"/>. This is the repository created by
+            calling <see cref="M:CreateRepository(string,Type)"/>.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="assembly">The assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository with the name specified.
+            </summary>
+            <param name="repositoryName">The name to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the name
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same name will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(Assembly, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(Assembly)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>
+            An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances created by 
+            this <see cref="T:log4net.Core.IRepositorySelector"/>.</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Create a new repository selector
+            </summary>
+            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new compact repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
+            </summary>
+            <param name="assembly">not used</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <param name="repositoryName">the name of the repository to lookup</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>. The default 
+            repository is <c>log4net-default-repository</c>. Other repositories 
+            must be created using the <see cref="M:CreateRepository(string, Type)"/>.
+            If the named repository does not exist an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> does not exist</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="assembly">not used</param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            If the <paramref name="repositoryType"/> is <c>null</c> then the
+            default repository type specified to the constructor is used.
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Create a new repository for the repository specified
+            </summary>
+            <param name="repositoryName">the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is null then the default repository type is used.</param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            <para>
+            If the named repository already exists an exception will be thrown.
+            </para>
+            <para>
+            If <paramref name="repositoryType"/> is <c>null</c> then the default 
+            repository type specified to the constructor is used.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> already exists</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.CompactRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the CompactRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notify the registered listeners that the repository has been created
+            </summary>
+            <param name="repository">The repository that has been created</param>
+            <remarks>
+            <para>
+            Raises the <event cref="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">LoggerRepositoryCreatedEvent</event>
+            event.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.DefaultRepositorySelector">
+            <summary>
+            The default implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Uses attributes defined on the calling assembly to determine how to
+            configure the hierarchy for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Creates a new repository selector.
+            </summary>
+            <param name="defaultRepositoryType">The type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null"/>.</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="repositoryAssembly">The assembly use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <remarks>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and the repository 
+            to create can be overridden by specifying the <see cref="T:log4net.Config.RepositoryAttribute"/> 
+            attribute on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> 
+            implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically configured using 
+            any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
+            the <paramref name="repositoryAssembly"/>.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.</returns>
+            <remarks>
+            <para>
+            Returns the named repository. If <paramref name="repositoryName"/> is <c>null</c>
+            a <see cref="T:System.ArgumentNullException"/> is thrown. If the repository 
+            does not exist a <see cref="T:log4net.Core.LogException"/> is thrown.
+            </para>
+            <para>
+            Use <see cref="M:CreateRepository(string, Type)"/> to create a repository.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> does not exist.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type,System.String,System.Boolean)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryName">The name to assign to the created repository</param>
+            <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is <see langword="null"/> then the default repository type is used.</param>
+            <returns>The new repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.AliasRepository(System.String,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Aliases a repository to an existing repository.
+            </summary>
+            <param name="repositoryAlias">The repository to alias.</param>
+            <param name="repositoryTarget">The repository that the repository is aliased to.</param>
+            <remarks>
+            <para>
+            The repository specified will be aliased to the repository when created. 
+            The repository must not already exist.
+            </para>
+            <para>
+            When the repository is created it must utilize the same repository type as 
+            the repository it is aliased to, otherwise the aliasing will fail.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="repositoryAlias"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repositoryTarget"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notifies the registered listeners that the repository has been created.
+            </summary>
+            <param name="repository">The repository that has been created.</param>
+            <remarks>
+            <para>
+            Raises the <see cref="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">
+            <summary>
+            Gets the repository name and repository type for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly that has a <see cref="T:log4net.Config.RepositoryAttribute"/>.</param>
+            <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>
+            <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>
+            <exception cref="T:System.ArgumentNullException"><paramref name="assembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the repository using information from the assembly.
+            </summary>
+            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>
+            attributes which define the configuration for the repository.</param>
+            <param name="repository">The repository to configure.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadPlugins(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined plugins on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to add the plugins to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadAliases(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined aliases on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to alias to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="F:log4net.Core.DefaultRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the DefaultRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ErrorCode">
+            <summary>
+            Defined error codes that can be passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Values passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.GenericFailure">
+            <summary>
+            A general error
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.WriteFailure">
+            <summary>
+            Error while writing output
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FlushFailure">
+            <summary>
+            Failed to flush file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.CloseFailure">
+            <summary>
+            Failed to close file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FileOpenFailure">
+            <summary>
+            Unable to open output file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.MissingLayout">
+            <summary>
+            No layout specified
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.AddressParseFailure">
+            <summary>
+            Failed to parse address
+            </summary>
+        </member>
+        <member name="T:log4net.Core.ExceptionEvaluator">
+            <summary>
+            An evaluator that triggers on an Exception type
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the type of the Exception
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to a Type in <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.    /// 
+            </para>
+            </remarks>
+            <author>Drew Schaeffer</author>
+        </member>
+        <member name="T:log4net.Core.ITriggeringEventEvaluator">
+            <summary>
+            Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action
+            </summary>
+            <remarks>
+            <para>
+            Implementations of this interface allow certain appenders to decide
+            when to perform an appender specific action.
+            </para>
+            <para>
+            The action or behavior triggered is defined by the implementation.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if this event triggers the action
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
+            <remarks>
+            <para>
+            Return <c>true</c> if this event triggers the action
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_type">
+            <summary>
+            The type that causes the trigger to fire.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_triggerOnSubclass">
+            <summary>
+            Causes subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/> to cause the trigger to fire.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor">
+            <summary>
+            Default ctor to allow dynamic creation through a configurator.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor(System.Type,System.Boolean)">
+            <summary>
+            Constructs an evaluator and initializes to trigger on <paramref name="exType"/>
+            </summary>
+            <param name="exType">the type that triggers this evaluator.</param>
+            <param name="triggerOnSubClass">If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.</param>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the logging event Exception 
+            Type is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the Exception Type of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.ExceptionType">
+            <summary>
+            The type that triggers this evaluator.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.TriggerOnSubclass">
+            <summary>
+            If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.IErrorHandler">
+            <summary>
+            Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.
+            </summary>
+            <remarks>
+            <para>
+            Error handling is a particularly tedious to get right because by
+            definition errors are hard to predict and to reproduce. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <param name="errorCode">The error code associated with the error.</param>
+            <remarks>
+            <para>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IFixingRequired">
+            <summary>
+            Interface for objects that require fixing.
+            </summary>
+            <remarks>
+            <para>
+            Interface that indicates that the object requires fixing before it
+            can be taken outside the context of the appender's 
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            When objects that implement this interface are stored 
+            in the context properties maps <see cref="T:log4net.GlobalContext"/>
+            <see cref="P:log4net.GlobalContext.Properties"/> and <see cref="T:log4net.ThreadContext"/>
+            <see cref="P:log4net.ThreadContext.Properties"/> are fixed 
+            (see <see cref="P:log4net.Core.LoggingEvent.Fix"/>) the <see cref="M:log4net.Core.IFixingRequired.GetFixedObject"/>
+            method will be called.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IFixingRequired.GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a portable instance object that represents the current
+            state of this object. The portable object can be stored
+            and logged from any thread with identical results.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILogger">
+            <summary>
+            Interface that all loggers implement
+            </summary>
+            <remarks>
+            <para>
+            This interface supports logging events and testing if a level
+            is enabled for logging.
+            </para>
+            <para>
+            These methods will not throw exceptions. Note to implementor, ensure
+            that the implementation of these methods cannot allow an exception
+            to be thrown to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">the exception to log, including its stack trace. Pass <c>null</c> to not log an exception.</param>
+            <remarks>
+            <para>
+            Generates a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="T:log4net.Core.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Name">
+            <summary>
+            Gets the name of the logger.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILoggerWrapper">
+            <summary>
+            Base interface for all wrappers
+            </summary>
+            <remarks>
+            <para>
+            Base interface for all wrappers.
+            </para>
+            <para>
+            All wrappers must implement this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Core.ILoggerWrapper.Logger">
+            <summary>
+            Get the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this
+            object. The <c>Logger</c> object may not 
+            be the same object as this object because of logger decorators.
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventHandler">
+            <summary>
+            Delegate used to handle logger repository creation event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Core.IRepositorySelector"/> which created the repository.</param>
+            <param name="e">The <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> event args
+            that holds the <see cref="T:log4net.Repository.ILoggerRepository"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> 
+            event is raised every time a <see cref="T:log4net.Repository.ILoggerRepository"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerRepositoryCreationEventArgs.m_repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggerRepositoryCreationEventArgs.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </summary>
+            <param name="repository">the <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created</param>
+            <remarks>
+            <para>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggerRepositoryCreationEventArgs.LoggerRepository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.Level">
+            <summary>
+            Defines the default set of levels recognized by the system.
+            </summary>
+            <remarks>
+            <para>
+            Each <see cref="T:log4net.Core.LoggingEvent"/> has an associated <see cref="T:log4net.Core.Level"/>.
+            </para>
+            <para>
+            Levels have a numeric <see cref="P:log4net.Core.Level.Value"/> that defines the relative 
+            ordering between levels. Two Levels with the same <see cref="P:log4net.Core.Level.Value"/> 
+            are deemed to be equivalent.
+            </para>
+            <para>
+            The levels that are recognized by log4net are set for each <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and each repository can have different levels defined. The levels are stored
+            in the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> on the repository. Levels are
+            looked up by name from the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>.
+            </para>
+            <para>
+            When logging at level INFO the actual level used is not <see cref="F:log4net.Core.Level.Info"/> but
+            the value of <c>LoggerRepository.LevelMap["INFO"]</c>. The default value for this is
+            <see cref="F:log4net.Core.Level.Info"/>, but this can be changed by reconfiguring the level map.
+            </para>
+            <para>
+            Each level has a <see cref="P:log4net.Core.Level.DisplayName"/> in addition to its <see cref="P:log4net.Core.Level.Name"/>. The 
+            <see cref="P:log4net.Core.Level.DisplayName"/> is the string that is written into the output log. By default
+            the display name is the same as the level name, but this can be used to alias levels
+            or to localize the log output.
+            </para>
+            <para>
+            Some of the predefined levels recognized by the system are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Off"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Fatal"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Error"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Warn"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Info"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Debug"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.All"/>.</description>
+            	</item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <param name="displayName">The display name for this level. This may be localized or otherwise different from the name</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.ToString">
+            <summary>
+            Returns the <see cref="T:System.String"/> representation of the current 
+            <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <returns>
+            A <see cref="T:System.String"/> representation of the current <see cref="T:log4net.Core.Level"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns the level <see cref="P:log4net.Core.Level.Name"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Equals(System.Object)">
+            <summary>
+            Compares levels.
+            </summary>
+            <param name="o">The object to compare against.</param>
+            <returns><c>true</c> if the objects are equal.</returns>
+            <remarks>
+            <para>
+            Compares the levels of <see cref="T:log4net.Core.Level"/> instances, and 
+            defers to base class if the target object is not a <see cref="T:log4net.Core.Level"/>
+            instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.GetHashCode">
+            <summary>
+            Returns a hash code
+            </summary>
+            <returns>A hash code for the current <see cref="T:log4net.Core.Level"/>.</returns>
+            <remarks>
+            <para>
+            Returns a hash code suitable for use in hashing algorithms and data 
+            structures like a hash table.
+            </para>
+            <para>
+            Returns the hash code of the level <see cref="P:log4net.Core.Level.Value"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.CompareTo(System.Object)">
+            <summary>
+            Compares this instance to a specified object and returns an 
+            indication of their relative values.
+            </summary>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> instance or <see langword="null"/> to compare with this instance.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description>This instance is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description>This instance is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description>
+            			<para>This instance is greater than <paramref name="r"/>.</para>
+            			<para>-or-</para>
+            			<para><paramref name="r"/> is <see langword="null"/>.</para>
+            			</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            <paramref name="r"/> must be an instance of <see cref="T:log4net.Core.Level"/> 
+            or <see langword="null"/>; otherwise, an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException"><paramref name="r"/> is not a <see cref="T:log4net.Core.Level"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Equality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have the same value.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is the same as the 
+            value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Inequality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have different values.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is different from
+            the value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Compare(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Compares two specified <see cref="T:log4net.Core.Level"/> instances.
+            </summary>
+            <param name="l">The first <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <param name="r">The second <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            two values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description><paramref name="l"/> is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description><paramref name="l"/> is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description><paramref name="l"/> is greater than <paramref name="r"/>.</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.Level.Off">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Off"/> level designates a higher level than all the rest.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Log4Net_Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Emergency">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fatal">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fatal"/> level designates very severe error events 
+            that will presumably lead the application to abort.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Alert">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Alert"/> level designates very severe error events. 
+            Take immediate action, alerts.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Critical">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Critical"/> level designates very severe error events. 
+            Critical condition, critical.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Severe">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Severe"/> level designates very severe error events.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Error">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Error"/> level designates error events that might 
+            still allow the application to continue running.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Warn">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Warn"/> level designates potentially harmful 
+            situations.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Notice">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Notice"/> level designates informational messages 
+            that highlight the progress of the application at the highest level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Info">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Info"/> level designates informational messages that 
+            highlight the progress of the application at coarse-grained level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Debug"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fine">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fine"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Trace">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Trace"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finer">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finer"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Verbose">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Verbose"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finest">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finest"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.All">
+            <summary>
+            The <see cref="F:log4net.Core.Level.All"/> level designates the lowest level possible.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.Level.Name">
+            <summary>
+            Gets the name of this level.
+            </summary>
+            <value>
+            The name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.Value">
+            <summary>
+            Gets the value of this level.
+            </summary>
+            <value>
+            The value of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the value of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.DisplayName">
+            <summary>
+            Gets the display name of this level.
+            </summary>
+            <value>
+            The display name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the display name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Core.Level"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ReadOnly(log4net.Core.LevelCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>LevelCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>LevelCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>LevelCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <c>LevelCollection</c>.
+            </summary>
+            <param name="c">The <c>LevelCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.Level[])">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Core.Level"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[])">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[],System.Int32)">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Add(log4net.Core.Level)">
+            <summary>
+            Adds a <see cref="T:log4net.Core.Level"/> to the end of the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to be added to the end of the <c>LevelCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clear">
+            <summary>
+            Removes all elements from the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Core.LevelCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Contains(log4net.Core.Level)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Core.Level"/> is in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.IndexOf(log4net.Core.Level)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Core.Level"/>
+            in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to locate in the <c>LevelCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>LevelCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Insert(System.Int32,log4net.Core.Level)">
+            <summary>
+            Inserts an element into the <c>LevelCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Remove(log4net.Core.Level)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Core.Level"/> from the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to remove from the <c>LevelCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Core.Level"/> was not found in the <c>LevelCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>LevelCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>LevelCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Core.LevelCollection.Enumerator"/> for the entire <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.LevelCollection)">
+            <summary>
+            Adds the elements of another <c>LevelCollection</c> to the current <c>LevelCollection</c>.
+            </summary>
+            <param name="x">The <c>LevelCollection</c> whose elements should be added to the end of the current <c>LevelCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.Level[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> array to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> collection to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.Level"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>LevelCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.ILevelCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LevelCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelEvaluator">
+            <summary>
+            An evaluator that triggers at a threshold level
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelEvaluator.m_threshold">
+            <summary>
+            The threshold for triggering
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor(log4net.Core.Level)">
+            <summary>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </summary>
+            <param name="threshold">the threshold to trigger at</param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the event level
+            is equal or higher than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelEvaluator.Threshold">
+            <summary>
+            the threshold to trigger at
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.Level"/> that will cause this evaluator to trigger
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelMap">
+            <summary>
+            Mapping between string name and Level object
+            </summary>
+            <remarks>
+            <para>
+            Mapping between string name and <see cref="T:log4net.Core.Level"/> object.
+            This mapping is held separately for each <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The level name is case insensitive.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelMap.m_mapName2Level">
+            <summary>
+            Mapping from level name to Level object. The
+            level name is case insensitive
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelMap.#ctor">
+            <summary>
+            Construct the level map
+            </summary>
+            <remarks>
+            <para>
+            Construct the level map.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Clear">
+            <summary>
+            Clear the internal maps of all levels
+            </summary>
+            <remarks>
+            <para>
+            Clear the internal maps of all levels
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+            <seealso cref="M:Add(string,int,string)"/>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32,System.String)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <param name="displayName">the display name to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(log4net.Core.Level)">
+            <summary>
+            Add a Level to the map
+            </summary>
+            <param name="level">the Level to add</param>
+            <remarks>
+            <para>
+            Add a Level to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.LookupWithDefault(log4net.Core.Level)">
+            <summary>
+            Lookup a named level from the map
+            </summary>
+            <param name="defaultLevel">the name of the level to lookup is taken from this level. 
+            If the level is not set on the map then this level is added</param>
+            <returns>the level in the map with the name specified</returns>
+            <remarks>
+            <para>
+            Lookup a named level from the map. The name of the level to lookup is taken
+            from the <see cref="P:log4net.Core.Level.Name"/> property of the <paramref name="defaultLevel"/>
+            argument.
+            </para>
+            <para>
+            If no level with the specified name is found then the 
+            <paramref name="defaultLevel"/> argument is added to the level map
+            and returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.Item(System.String)">
+            <summary>
+            Lookup a <see cref="T:log4net.Core.Level"/> by name
+            </summary>
+            <param name="name">The name of the Level to lookup</param>
+            <returns>a Level from the map with the name specified</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:log4net.Core.Level"/> from the
+            map with the name specified. If the no level is
+            found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.AllLevels">
+            <summary>
+            Return all possible levels as a list of Level objects.
+            </summary>
+            <returns>all possible levels as a list of Level objects</returns>
+            <remarks>
+            <para>
+            Return all possible levels as a list of Level objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LocationInfo">
+            <summary>
+            The internal representation of caller location information.
+            </summary>
+            <remarks>
+            <para>
+            This class uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.Type)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class based on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="className">The fully qualified class name.</param>
+            <param name="methodName">The method name.</param>
+            <param name="fileName">The file name.</param>
+            <param name="lineNumber">The line number of the method within the file.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class with the specified data.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.declaringType">
+            <summary>
+            The fully qualified type of the LocationInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.MethodName">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.StackFrames">
+            <summary>
+            Gets the stack frames from the stack trace of the caller making the log request
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LoggerManager">
+            <summary>
+            Static manager that controls the creation of repositories
+            </summary>
+            <remarks>
+            <para>
+            Static manager that controls the creation of repositories
+            </para>
+            <para>
+            This class is used by the wrapper managers (e.g. <see cref="T:log4net.LogManager"/>)
+            to provide access to the <see cref="T:log4net.Core.ILogger"/> objects.
+            </para>
+            <para>
+            This manager also holds the <see cref="T:log4net.Core.IRepositorySelector"/> that is used to
+            lookup and create repositories. The selector can be set either programmatically using
+            the <see cref="P:log4net.Core.LoggerManager.RepositorySelector"/> property, or by setting the <c>log4net.RepositorySelector</c>
+            AppSetting in the applications config file to the fully qualified type name of the
+            selector to use. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#ctor">
+            <summary>
+            Private constructor to prevent instances. Only static methods should be used.
+            </summary>
+            <remarks>
+            <para>
+            Private constructor to prevent instances. Only static methods should be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#cctor">
+            <summary>
+            Hook the shutdown event
+            </summary>
+            <remarks>
+            <para>
+            On the full .NET runtime, the static constructor hooks up the 
+            <c>AppDomain.ProcessExit</c> and <c>AppDomain.DomainUnload</c>> events. 
+            These are used to shutdown the log4net system as the application exits.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.RegisterAppDomainEvents">
+            <summary>
+            Register for ProcessExit and DomainUnload events on the AppDomain
+            </summary>
+            <remarks>
+            <para>
+            This needs to be in a separate method because the events make
+            a LinkDemand for the ControlAppDomain SecurityPermission. Because
+            this is a LinkDemand it is demanded at JIT time. Therefore we cannot
+            catch the exception in the method itself, we have to catch it in the
+            caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified assembly's repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified assembly's repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to lookup the repository</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repository">The repository to shutdown.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repository">The repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+            <remarks>
+            <para>
+            Gets an array of all currently defined repositories.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetVersionInfo">
+            <summary>
+            Internal method to get pertinent version info.
+            </summary>
+            <returns>A string of version info.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnDomainUnload(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnProcessExit(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.declaringType">
+            <summary>
+            The fully qualified type of the LoggerManager class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.s_repositorySelector">
+            <summary>
+            Initialize the default repository selector
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerManager.RepositorySelector">
+            <summary>
+            Gets or sets the repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </summary>
+            <value>
+            The repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </value>
+            <remarks>
+            <para>
+            The repository selector (<see cref="T:log4net.Core.IRepositorySelector"/>) is used by 
+            the <see cref="T:log4net.LogManager"/> to create and select repositories 
+            (<see cref="T:log4net.Repository.ILoggerRepository"/>).
+            </para>
+            <para>
+            The caller to <see cref="T:log4net.LogManager"/> supplies either a string name 
+            or an assembly (if not supplied the assembly is inferred using 
+            <see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            <para>
+            This context is used by the selector to lookup a specific repository.
+            </para>
+            <para>
+            For the full .NET Framework, the default repository is <c>DefaultRepositorySelector</c>;
+            for the .NET Compact Framework <c>CompactRepositorySelector</c> is the default
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerWrapperImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.ILoggerWrapper"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This class should be used as the base for all wrapper implementations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerWrapperImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Constructs a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Constructs a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerWrapperImpl.m_logger">
+            <summary>
+            The logger that this object is wrapping
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerWrapperImpl.Logger">
+            <summary>
+            Gets the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that this object is implementing.
+            </value>
+            <remarks>
+            <para>
+            The <c>Logger</c> object may not be the same object as this object 
+            because of logger decorators.
+            </para>
+            <para>
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEventData">
+            <summary>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LoggerName">
+            <summary>
+            The logger name.
+            </summary>
+            <remarks>
+            <para>
+            The logger name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Level">
+            <summary>
+            Level of logging event.
+            </summary>
+            <remarks>
+            <para>
+            Level of logging event. Level cannot be Serializable
+            because it is a flyweight.  Due to its special serialization it
+            cannot be declared final either.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Message">
+            <summary>
+            The application supplied message.
+            </summary>
+            <remarks>
+            <para>
+            The application supplied message of logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ThreadName">
+            <summary>
+            The name of thread
+            </summary>
+            <remarks>
+            <para>
+            The name of thread in which this logging event was generated
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.TimeStamp">
+            <summary>
+            Gets or sets the local time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            Prefer using the <see cref="P:log4net.Core.LoggingEventData.TimeStampUtc"/> setter, since local time can be ambiguous.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LocationInfo">
+            <summary>
+            Location information for the caller.
+            </summary>
+            <remarks>
+            <para>
+            Location information for the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.UserName">
+            <summary>
+            String representation of the user
+            </summary>
+            <remarks>
+            <para>
+            String representation of the user's windows name,
+            like DOMAIN\username
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Identity">
+            <summary>
+            String representation of the identity.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the current thread's principal identity.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ExceptionString">
+            <summary>
+            The string representation of the exception
+            </summary>
+            <remarks>
+            <para>
+            The string representation of the exception
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Domain">
+            <summary>
+            String representation of the AppDomain.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Properties">
+            <summary>
+            Additional event specific properties
+            </summary>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEventData.TimeStampUtc">
+            <summary>
+            Gets or sets the UTC time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            The TimeStamp is stored in the UTC time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.FixFlags">
+            <summary>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </summary>
+            <remarks>
+            <para>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Mdc">
+            <summary>
+            Fix the MDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Ndc">
+            <summary>
+            Fix the NDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Message">
+            <summary>
+            Fix the rendered message
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.ThreadName">
+            <summary>
+            Fix the thread name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.LocationInfo">
+            <summary>
+            Fix the callers location information
+            </summary>
+            <remarks>
+            CAUTION: Very slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.UserName">
+            <summary>
+            Fix the callers windows user name
+            </summary>
+            <remarks>
+            CAUTION: Slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Domain">
+            <summary>
+            Fix the domain friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Identity">
+            <summary>
+            Fix the callers principal name
+            </summary>
+            <remarks>
+            CAUTION: May be slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Exception">
+            <summary>
+            Fix the exception text
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Properties">
+            <summary>
+            Fix the event properties. Active properties must implement <see cref="T:log4net.Core.IFixingRequired"/> in order to be eligible for fixing.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.None">
+            <summary>
+            No fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.All">
+            <summary>
+            All fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Partial">
+            <summary>
+            Partial fields fixed
+            </summary>
+            <remarks>
+            <para>
+            This set of partial fields gives good performance. The following fields are fixed:
+            </para>
+            <list type="bullet">
+            <item><description><see cref="F:log4net.Core.FixFlags.Message"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.ThreadName"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Exception"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Domain"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Properties"/></description></item>
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEvent">
+            <summary>
+            The internal representation of logging events. 
+            </summary>
+            <remarks>
+            <para>
+            When an affirmative decision is made to log then a 
+            <see cref="T:log4net.Core.LoggingEvent"/> instance is created. This instance 
+            is passed around to the different log4net components.
+            </para>
+            <para>
+            This class is of concern to those wishing to extend log4net.
+            </para>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.HostNameProperty">
+            <summary>
+            The key into the Properties map for the host name value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.IdentityProperty">
+            <summary>
+            The key into the Properties map for the thread identity value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.UserNameProperty">
+            <summary>
+            The key into the Properties map for the user name value.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,System.String,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class
+            from the supplied parameters.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="loggerName">The name of the logger of this event.</param>
+            <param name="level">The level of this event.</param>
+            <param name="message">The message of this event.</param>
+            <param name="exception">The exception for this event.</param>
+            <remarks>
+            <para>
+            Except <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.Core.LoggingEvent.Level"/> and <see cref="P:log4net.Core.LoggingEvent.LoggerName"/>, 
+            all fields of <c>LoggingEvent</c> are filled when actually needed. Call
+            <see cref="M:FixVolatileData()"/> to cache all data locally
+            to prevent inconsistencies.
+            </para>
+            <para>This method is called by the log4net framework
+            to create a logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData,log4net.Core.FixFlags)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            The <paramref name="fixedData"/> parameter should be used to specify which fields in the
+            <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>
+            will be captured from the environment if requested or fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.EnsureRepository(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Ensure that the repository is set.
+            </summary>
+            <param name="repository">the value for the repository</param>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)">
+            <summary>
+            Write the rendered message to a TextWriter
+            </summary>
+            <param name="writer">the writer to write the message to</param>
+            <remarks>
+            <para>
+            Unlike the <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property this method
+            does store the message data in the internal cache. Therefore 
+            if called only once this method should be faster than the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property, however if the message is
+            to be accessed multiple times then the property will be more efficient.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            The data in this event must be fixed before it can be serialized.
+            </para>
+            <para>
+            The <see cref="M:FixVolatileData()"/> method must be called during the
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method call if this event 
+            is to be used outside that method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            <para>
+            Does a <see cref="F:log4net.Core.FixFlags.Partial"/> fix of the data
+            in the logging event before returning the event data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData(log4net.Core.FixFlags)">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionStrRep">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            <b>Obsolete. Use <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> instead.</b>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionString">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData">
+            <summary>
+            Fix instance fields that hold volatile data.
+            </summary>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            Calling <see cref="M:FixVolatileData()"/> is equivalent to
+            calling <see cref="M:FixVolatileData(bool)"/> passing the parameter
+            <c>false</c>.
+            </para>
+            <para>
+            See <see cref="M:FixVolatileData(bool)"/> for more
+            information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)">
+            <summary>
+            Fixes instance fields that hold volatile data.
+            </summary>
+            <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            The <paramref name="fastButLoose"/> param controls the data that
+            is fixed. Some of the data that can be fixed takes a long time to 
+            generate, therefore if you do not require those settings to be fixed
+            they can be ignored by setting the <paramref name="fastButLoose"/> param
+            to <c>true</c>. This setting will ignore the <see cref="P:log4net.Core.LoggingEvent.LocationInformation"/>
+            and <see cref="P:log4net.Core.LoggingEvent.UserName"/> settings.
+            </para>
+            <para>
+            Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all 
+            settings are fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)">
+            <summary>
+            Fix the fields specified by the <see cref="T:log4net.Core.FixFlags"/> parameter
+            </summary>
+            <param name="flags">the fields to fix</param>
+            <remarks>
+            <para>
+            Only fields specified in the <paramref name="flags"/> will be fixed.
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.LookupProperty(System.String)">
+            <summary>
+            Lookup a composite property in this event
+            </summary>
+            <param name="key">the key for the property to lookup</param>
+            <returns>the value for the property</returns>
+            <remarks>
+            <para>
+            This event has composite properties that combine together properties from
+            several different contexts in the following order:
+            <list type="definition">
+            	<item>
+            		<term>this events properties</term>
+            		<description>
+            		This event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            		properties are specific to this event only.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the thread properties</term>
+            		<description>
+            		The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            		thread. These properties are shared by all events logged on this thread.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the global properties</term>
+            		<description>
+            		The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            		properties are shared by all the threads in the AppDomain.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetProperties">
+            <summary>
+            Get all the composite properties in this event
+            </summary>
+            <returns>the <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the properties</returns>
+            <remarks>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/> for details of the composite properties 
+            stored by the event.
+            </para>
+            <para>
+            This method returns a single <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the
+            properties defined for this event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_data">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_compositeProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_eventProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_callerStackBoundaryDeclaringType">
+            <summary>
+            The fully qualified Type of the calling 
+            logger class in the stack frame (i.e. the declaring type of the method).
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_message">
+            <summary>
+            The application supplied message of logging event.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_thrownException">
+            <summary>
+            The exception that was thrown.
+            </summary>
+            <remarks>
+            This is not serialized. The string representation
+            is serialized instead.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_repository">
+            <summary>
+            The repository that generated the logging event
+            </summary>
+            <remarks>
+            This is not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_fixFlags">
+            <summary>
+            The fix state for this event
+            </summary>
+            <remarks>
+            These flags indicate which fields have been fixed.
+            Not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_cacheUpdatable">
+            <summary>
+            Indicated that the internal cache is updateable (ie not fixed)
+            </summary>
+            <remarks>
+            This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler
+            changes in the caching strategy.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTime">
+            <summary>
+            Gets the time when the current process started.
+            </summary>
+            <value>
+            This is the time when this process started.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored internally in UTC and converted to the local time zone for this computer.
+            </para>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTimeUtc">
+            <summary>
+            Gets the UTC time when the current process started.
+            </summary>
+            <value>
+            This is the UTC time when this process started.
+            </value>
+            <remarks>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Level">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStamp">
+            <summary>
+            Gets the time of the logging event.
+            </summary>
+            <value>
+            The time of the logging event.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored in UTC and converted to the local time zone for this computer.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStampUtc">
+            <summary>
+            Gets UTC the time of the logging event.
+            </summary>
+            <value>
+            The UTC time of the logging event.
+            </value>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LoggerName">
+            <summary>
+            Gets the name of the logger that logged the event.
+            </summary>
+            <value>
+            The name of the logger that logged the event.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of the logger that logged the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LocationInformation">
+            <summary>
+            Gets the location information for this logging event.
+            </summary>
+            <value>
+            The location information for this logging event.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Core.LocationInfo"/> class for more information on
+            supported frameworks and the different behavior in Debug and
+            Release builds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.MessageObject">
+            <summary>
+            Gets the message object used to initialize this event.
+            </summary>
+            <value>
+            The message object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the message object used to initialize this event.
+            Note that this event may not have a valid message object.
+            If the event is serialized the message object will not 
+            be transferred. To get the text of the message the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined message object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ExceptionObject">
+            <summary>
+            Gets the exception object used to initialize this event.
+            </summary>
+            <value>
+            The exception object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the exception object used to initialize this event.
+            Note that this event may not have a valid exception object.
+            If the event is serialized the exception object will not 
+            be transferred. To get the text of the exception the
+            <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> method must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined exception object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.RenderedMessage">
+            <summary>
+            Gets the message, rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <value>
+            The message rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ThreadName">
+            <summary>
+            Gets the name of the current thread.  
+            </summary>
+            <value>
+            The name of the current thread, or the thread ID when 
+            the name is not available.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.UserName">
+            <summary>
+            Gets the name of the current user.
+            </summary>
+            <value>
+            The name of the current user, or <c>NOT AVAILABLE</c> when the 
+            underlying runtime has no support for retrieving the name of the 
+            current user.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of
+            the current windows user.
+            </para>
+            <para>
+            To improve performance, we could cache the string representation of 
+            the name, and reuse that as long as the identity stayed constant.  
+            Once the identity changed, we would need to re-assign and re-render 
+            the string.
+            </para>
+            <para>
+            However, the <c>WindowsIdentity.GetCurrent()</c> call seems to 
+            return different objects every time, so the current implementation 
+            doesn't do this type of caching.
+            </para>
+            <para>
+            Timing for these operations:
+            </para>
+            <list type="table">
+              <listheader>
+                <term>Method</term>
+                <description>Results</description>
+              </listheader>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent()</c></term>
+                <description>10000 loops, 00:00:00.2031250 seconds</description>
+              </item>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent().Name</c></term>
+                <description>10000 loops, 00:00:08.0468750 seconds</description>
+              </item>
+            </list>
+            <para>
+            This means we could speed things up almost 40 times by caching the 
+            value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since 
+            this takes (8.04-0.20) = 7.84375 seconds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Identity">
+            <summary>
+            Gets the identity of the current thread principal.
+            </summary>
+            <value>
+            The string name of the identity of the current thread principal.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get
+            the name of the current thread principal.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Domain">
+            <summary>
+            Gets the AppDomain friendly name.
+            </summary>
+            <value>
+            The AppDomain friendly name.
+            </value>
+            <remarks>
+            <para>
+            Gets the AppDomain friendly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Properties">
+            <summary>
+            Additional event specific properties.
+            </summary>
+            <value>
+            Additional event specific properties.
+            </value>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            <para>
+            This property is for events that have been added directly to
+            this event. The aggregate properties (which include these
+            event properties) can be retrieved using <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/>
+            and <see cref="M:log4net.Core.LoggingEvent.GetProperties"/>.
+            </para>
+            <para>
+            Once the properties have been fixed <see cref="P:log4net.Core.LoggingEvent.Fix"/> this property
+            returns the combined cached properties. This ensures that updates to
+            this property are always reflected in the underlying storage. When
+            returning the combined properties there may be more keys in the
+            Dictionary than expected.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Fix">
+            <summary>
+            The fixed fields in this event
+            </summary>
+            <value>
+            The set of fields that are fixed in this event
+            </value>
+            <remarks>
+            <para>
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LogImpl">
+            <summary>
+            Implementation of <see cref="T:log4net.ILog"/> wrapper interface.
+            </summary>
+            <remarks>
+            <para>
+            This implementation of the <see cref="T:log4net.ILog"/> interface
+            forwards to the <see cref="T:log4net.Core.ILogger"/> held by the base class.
+            </para>
+            <para>
+            This logger has methods to allow the caller to log at the following
+            levels:
+            </para>
+            <list type="definition">
+              <item>
+                <term>DEBUG</term>
+                <description>
+                The <see cref="M:Debug(object)"/> and <see cref="M:DebugFormat(string, object[])"/> methods log messages
+                at the <c>DEBUG</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Debug"/>. The <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>INFO</term>
+                <description>
+                The <see cref="M:Info(object)"/> and <see cref="M:InfoFormat(string, object[])"/> methods log messages
+                at the <c>INFO</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Info"/>. The <see cref="P:log4net.Core.LogImpl.IsInfoEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>WARN</term>
+                <description>
+                The <see cref="M:Warn(object)"/> and <see cref="M:WarnFormat(string, object[])"/> methods log messages
+                at the <c>WARN</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Warn"/>. The <see cref="P:log4net.Core.LogImpl.IsWarnEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>ERROR</term>
+                <description>
+                The <see cref="M:Error(object)"/> and <see cref="M:ErrorFormat(string, object[])"/> methods log messages
+                at the <c>ERROR</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Error"/>. The <see cref="P:log4net.Core.LogImpl.IsErrorEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>FATAL</term>
+                <description>
+                The <see cref="M:Fatal(object)"/> and <see cref="M:FatalFormat(string, object[])"/> methods log messages
+                at the <c>FATAL</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Fatal"/>. The <see cref="P:log4net.Core.LogImpl.IsFatalEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+            </list>
+            <para>
+            The values for these levels and their semantic meanings can be changed by 
+            configuring the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ILog">
+            <summary>
+            The ILog interface is use by application to log messages into
+            the log4net framework.
+            </summary>
+            <remarks>
+            <para>
+            Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
+            that implement this interface. The <see cref="M:LogManager.GetLogger(Assembly,Type)"/>
+            static method is used to get logger instances.
+            </para>
+            <para>
+            This class contains methods for logging at different levels and also
+            has properties for determining if those logging levels are
+            enabled in the current configuration.
+            </para>
+            <para>
+            This interface can be implemented in different ways. This documentation
+            specifies reasonable behavior that a caller can expect from the actual
+            implementation, however different implementations reserve the right to
+            do things differently.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <seealso cref="T:log4net.LogManager"/>
+            <seealso cref="M:LogManager.GetLogger(Assembly, Type)"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">
+            <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para> For some ILog interface <c>log</c>, when you write:</para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, string construction and concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed (who isn't), then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
+            the <see cref="M:Debug(object)"/>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log. This is the preferred style of logging.
+            </para>
+            <para>Alternatively if your logger is available statically then the is debug
+            enabled state can be stored in a static variable like this:
+            </para>
+            <code lang="C#">
+            private static readonly bool isDebugEnabled = log.IsDebugEnabled;
+            </code>
+            <para>
+            Then when you come to log you can write:
+            </para>
+            <code lang="C#">
+            if (isDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way the debug enabled state is only queried once
+            when the class is loaded. Using a <c>private static readonly</c>
+            variable is the most efficient because it is a run time constant
+            and can be heavily optimized by the JIT compiler.
+            </para>
+            <para>
+            Of course if you use a static readonly variable to
+            hold the enabled state of the logger then you cannot
+            change the enabled state at runtime to vary the logging
+            that is produced. You have to decide if you need absolute
+            speed or runtime flexibility.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="M:DebugFormat(IFormatProvider, string, object[])"/>
+        </member>
+        <member name="P:log4net.ILog.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="M:InfoFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="M:WarnFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="M:ErrorFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="M:FatalFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Construct a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Construct a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ReloadLevels(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Virtual method called when the configuration of the repository changes
+            </summary>
+            <param name="repository">the repository holding the levels</param>
+            <remarks>
+            <para>
+            Virtual method called when the configuration of the repository changes
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <c>DEBUG</c> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>DEBUG</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> passed
+            as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <c>INFO</c> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level.
+            </summary>
+            <param name="message">the message object to log</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <c>WARN</c> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>WARN</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <c>ERROR</c> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>ERROR</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <c>FATAL</c> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>FATAL</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.LoggerRepositoryConfigurationChanged(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for the <see cref="E:log4net.Repository.ILoggerRepository.ConfigurationChanged"/> event
+            </summary>
+            <param name="sender">the repository</param>
+            <param name="e">Empty</param>
+        </member>
+        <member name="F:log4net.Core.LogImpl.ThisDeclaringType">
+            <summary>
+            The fully qualified name of this declaring type not the type of any subclass.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>DEBUG</c>
+            level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>DEBUG</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para>
+            For some <c>log</c> Logger object, when you write:
+            </para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed, then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled())
+            { 
+             log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <c>IsDebugEnabled</c> and once in
+            the <c>Debug</c>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>INFO</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>INFO</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>WARN</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>WARN</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>ERROR</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>ERROR</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>FATAL</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>FATAL</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="T:log4net.Core.MethodItem">
+            <summary>
+            provides method information without actually referencing a System.Reflection.MethodBase
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.MethodItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor">
+            <summary>
+            constructs a method item for an unknown method.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String)">
+            <summary>
+            constructs a method item from the name of the method.
+            </summary>
+            <param name="name"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String,System.String[])">
+            <summary>
+            constructs a method item from the name of the method and its parameters.
+            </summary>
+            <param name="name"></param>
+            <param name="parameters"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.Reflection.MethodBase)">
+            <summary>
+            constructs a method item from a method base by determining the method name and its parameters.
+            </summary>
+            <param name="methodBase"></param>
+        </member>
+        <member name="F:log4net.Core.MethodItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Name">
+            <summary>
+            Gets the method name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The method name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Parameters">
+            <summary>
+            Gets the method parameters of the caller making
+            the logging request.
+            </summary>
+            <value>
+            The method parameters of the caller making
+            the logging request
+            </value>
+            <remarks>
+            <para>
+            Gets the method parameters of the caller making
+            the logging request.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContext">
+            <summary>
+            A SecurityContext used by log4net when interacting with protected resources
+            </summary>
+            <remarks>
+            <para>
+            A SecurityContext used by log4net when interacting with protected resources
+            for example with operating system services. This can be used to impersonate
+            a principal that has been granted privileges on the system resources.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.SecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns>An <see cref="T:System.IDisposable"/> instance that will
+            revoke the impersonation of this SecurityContext, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Impersonate this security context. Further calls on the current
+            thread should now be made in the security context provided
+            by this object. When the <see cref="T:System.IDisposable"/> result 
+            <see cref="M:System.IDisposable.Dispose"/> method is called the security
+            context of the thread should be reverted to the state it was in
+            before <see cref="M:log4net.Core.SecurityContext.Impersonate(System.Object)"/> was called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContextProvider">
+            <summary>
+            The <see cref="T:log4net.Core.SecurityContextProvider"/> providers default <see cref="T:log4net.Core.SecurityContext"/> instances.
+            </summary>
+            <remarks>
+            <para>
+            A configured component that interacts with potentially protected system
+            resources uses a <see cref="T:log4net.Core.SecurityContext"/> to provide the elevated
+            privileges required. If the <see cref="T:log4net.Core.SecurityContext"/> object has
+            been not been explicitly provided to the component then the component
+            will request one from this <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </para>
+            <para>
+            By default the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is
+            an instance of <see cref="T:log4net.Core.SecurityContextProvider"/> which returns only
+            <see cref="T:log4net.Util.NullSecurityContext"/> objects. This is a reasonable default
+            where the privileges required are not know by the system.
+            </para>
+            <para>
+            This default behavior can be overridden by subclassing the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            and overriding the <see cref="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)"/> method to return
+            the desired <see cref="T:log4net.Core.SecurityContext"/> objects. The default provider
+            can be replaced by programmatically setting the value of the 
+            <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> property.
+            </para>
+            <para>
+            An alternative is to use the <c>log4net.Config.SecurityContextProviderAttribute</c>
+            This attribute can be applied to an assembly in the same way as the
+            <c>log4net.Config.XmlConfiguratorAttribute"</c>. The attribute takes
+            the type to use as the <see cref="T:log4net.Core.SecurityContextProvider"/> as an argument.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.SecurityContextProvider.s_defaultProvider">
+            <summary>
+            The default provider
+            </summary>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.#ctor">
+            <summary>
+            Protected default constructor to allow subclassing
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)">
+            <summary>
+            Create a SecurityContext for a consumer
+            </summary>
+            <param name="consumer">The consumer requesting the SecurityContext</param>
+            <returns>An impersonation context</returns>
+            <remarks>
+            <para>
+            The default implementation is to return a <see cref="T:log4net.Util.NullSecurityContext"/>.
+            </para>
+            <para>
+            Subclasses should override this method to provide their own
+            behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.SecurityContextProvider.DefaultProvider">
+            <summary>
+            Gets or sets the default SecurityContextProvider
+            </summary>
+            <value>
+            The default SecurityContextProvider
+            </value>
+            <remarks>
+            <para>
+            The default provider is used by configured components that
+            require a <see cref="T:log4net.Core.SecurityContext"/> and have not had one
+            given to them.
+            </para>
+            <para>
+            By default this is an instance of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that returns <see cref="T:log4net.Util.NullSecurityContext"/> objects.
+            </para>
+            <para>
+            The default provider can be set programmatically by setting
+            the value of this property to a sub class of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that has the desired behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.StackFrameItem">
+            <summary>
+            provides stack frame information without actually referencing a System.Diagnostics.StackFrame
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.StackFrameItem.#ctor(System.Diagnostics.StackFrame)">
+            <summary>
+            returns a stack frame item from a stack frame. This 
+            </summary>
+            <param name="frame"></param>
+            <returns></returns>
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.Method">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.TimeEvaluator">
+            <summary>
+            An evaluator that triggers after specified number of seconds.
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+            <author>Robert Sevcik</author>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL">
+            <summary>
+            The default time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_interval">
+            <summary>
+            The time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_lastTimeUtc">
+            <summary>
+            The UTC time of last check. This gets updated when the object is created and when the evaluator triggers.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor(System.Int32)">
+            <summary>
+            Create a new evaluator using the specified time threshold in seconds.
+            </summary>
+            <param name="interval">
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.TimeEvaluator.Interval">
+            <summary>
+            The time threshold in seconds to trigger after
+            </summary>
+            <value>
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperCreationHandler">
+            <summary>
+            Delegate used to handle creation of new wrappers.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <remarks>
+            <para>
+            Delegate used to handle creation of new wrappers. This delegate
+            is called from the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method to construct the wrapper for the specified logger.
+            </para>
+            <para>
+            The delegate to use is supplied to the <see cref="T:log4net.Core.WrapperMap"/>
+            constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperMap">
+            <summary>
+            Maps between logger objects and wrapper objects.
+            </summary>
+            <remarks>
+            <para>
+            This class maintains a mapping between <see cref="T:log4net.Core.ILogger"/> objects and
+            <see cref="T:log4net.Core.ILoggerWrapper"/> objects. Use the <see cref="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)"/> method to 
+            lookup the <see cref="T:log4net.Core.ILoggerWrapper"/> for the specified <see cref="T:log4net.Core.ILogger"/>.
+            </para>
+            <para>
+            New wrapper instances are created by the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method. The default behavior is for this method to delegate construction
+            of the wrapper to the <see cref="T:log4net.Core.WrapperCreationHandler"/> delegate supplied
+            to the constructor. This allows specialization of the behavior without
+            requiring subclassing of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.#ctor(log4net.Core.WrapperCreationHandler)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/>
+            </summary>
+            <param name="createWrapperHandler">The handler to use to create the wrapper objects.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/> class with 
+            the specified handler to create the wrapper objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)">
+            <summary>
+            Gets the wrapper object for the specified logger.
+            </summary>
+            <returns>The wrapper object for the specified logger</returns>
+            <remarks>
+            <para>
+            If the logger is null then the corresponding wrapper is null.
+            </para>
+            <para>
+            Looks up the wrapper it it has previously been requested and
+            returns it. If the wrapper has never been requested before then
+            the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/> virtual method is
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)">
+            <summary>
+            Creates the wrapper object for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <returns>The wrapper object for the logger.</returns>
+            <remarks>
+            <para>
+            This implementation uses the <see cref="T:log4net.Core.WrapperCreationHandler"/>
+            passed to the constructor to create the wrapper. This method
+            can be overridden in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.RepositoryShutdown(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Called when a monitored repository shutdown event is received.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down</param>
+            <remarks>
+            <para>
+            This method is called when a <see cref="T:log4net.Repository.ILoggerRepository"/> that this
+            <see cref="T:log4net.Core.WrapperMap"/> is holding loggers for has signaled its shutdown
+            event <see cref="E:log4net.Repository.ILoggerRepository.ShutdownEvent"/>. The default
+            behavior of this method is to release the references to the loggers
+            and their wrappers generated for this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.ILoggerRepository_Shutdown(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for repository shutdown event.
+            </summary>
+            <param name="sender">The sender of the event.</param>
+            <param name="e">The event args.</param>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_repositories">
+            <summary>
+            Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_createWrapperHandler">
+            <summary>
+            The handler to use to create the extension wrapper objects.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_shutdownHandler">
+            <summary>
+            Internal reference to the delegate used to register for repository shutdown events.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.WrapperMap.Repositories">
+            <summary>
+            Gets the map of logger repositories.
+            </summary>
+            <value>
+            Map of logger repositories.
+            </value>
+            <remarks>
+            <para>
+            Gets the hashtable that is keyed on <see cref="T:log4net.Repository.ILoggerRepository"/>. The
+            values are hashtables keyed on <see cref="T:log4net.Core.ILogger"/> with the
+            value being the corresponding <see cref="T:log4net.Core.ILoggerWrapper"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.DateFormatter.IDateFormatter">
+            <summary>
+            Render a <see cref="T:System.DateTime"/> as a string.
+            </summary>
+            <remarks>
+            <para>
+            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
+            instance into a string.
+            </para>
+            <para>
+            The <see cref="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/> method is used to render the
+            date to a text writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the specified date as a string.
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:System.DateTime"/> as a string and write it
+            to the <see cref="T:System.IO.TextWriter"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.AbsoluteTimeDateFormat">
+            <summary>
+            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DateAndTimeDateFormat">
+            <summary>
+            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.Iso8601TimeDateFormat">
+            <summary>
+            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Renders the date into a string. Format is <c>"HH:mm:ss"</c>.
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to render the date
+            into a string using a precision up to the second. This method
+            will be called at most once per second and the result will be
+            reused if it is needed again during the same second.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Renders the date into a string. Format is "HH:mm:ss,fff".
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> method to generate the
+            time string up to the seconds and then appends the current
+            milliseconds. The results from <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> are
+            cached and <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> is called at most once
+            per second.
+            </para>
+            <para>
+            Sub classes should override <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/>
+            rather than <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeToTheSecond">
+            <summary>
+            Last stored time with precision up to the second.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeBuf">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeStrings">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"dd MMM yyyy HH:mm:ss,fff"</c>
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format 
+            <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, 
+            <c>"06 Nov 1994 15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Angelika Schnagl</author>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">
+            <summary>
+            Default constructor.
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats a DateTime in the format <c>"dd MMM yyyy HH:mm:ss"</c>
+            for example, <c>"06 Nov 1994 15:49:37"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_dateTimeFormatInfo">
+            <summary>
+            The format info for the invariant culture.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.Iso8601DateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> as <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> specified as a string: <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats the date specified as a string: <c>"yyyy-MM-dd HH:mm:ss"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.SimpleDateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="T:System.DateTime"/> <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="format">The format string.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> class 
+            with the specified format string.
+            </para>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the date using <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </summary>
+            <param name="dateToFormat">The date to convert to a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the date format string supplied to the constructor to call
+            the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method to format the date.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">
+            <summary>
+            The format string used to format the <see cref="T:System.DateTime"/>.
+            </summary>
+            <remarks>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.DenyAllFilter">
+            <summary>
+            This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>. 
+            </summary>
+            <remarks>
+            <para>
+            You can add this filter to the end of a filter chain to
+            switch from the default "accept all unless instructed otherwise"
+            filtering behavior to a "deny all unless instructed otherwise"
+            behavior.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.FilterSkeleton">
+            <summary>
+            Subclass this type to implement customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should extend this class to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.IFilter">
+            <summary>
+            Implement this interface to provide customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should implement this interface to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the logging event should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The LoggingEvent to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.IFilter.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterSkeleton.m_next">
+            <summary>
+            Points to the next filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
+            <summary>
+            Initialize the filter with the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Typically filter's options become active immediately on set, 
+            however this method must still be called. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            <para>
+            This method is marked <c>abstract</c> and must be implemented
+            in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.FilterSkeleton.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            </summary>
+            <param name="loggingEvent">the LoggingEvent to filter</param>
+            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>
+            <remarks>
+            <para>
+            Ignores the event being logged and just returns
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter
+            chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter
+            should only be used as the last filter in the chain
+            as any further filters will be ignored!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.FilterDecision">
+            <summary>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </summary>
+            <remarks>
+            <para>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Deny">
+            <summary>
+            The log event must be dropped immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Neutral">
+            <summary>
+            This filter is neutral with respect to the log event. 
+            The remaining filters, if any, should be consulted for a final decision.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Accept">
+            <summary>
+            The log event must be logged immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="T:log4net.Filter.LevelMatchFilter">
+            <summary>
+            This is a very simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and
+            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value
+            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.Core.Level"/> of the 
+            <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 
+            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set
+            to <c>true</c>, if it is <c>false</c> then 
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">
+            <summary>
+            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.Accept"/> on a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">
+            <summary>
+            the <see cref="T:log4net.Core.Level"/> to match against
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Tests if the <see cref="T:log4net.Core.Level"/> of the logging event matches that of the filter
+            </summary>
+            <param name="loggingEvent">the event to filter</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the event matches the level of the
+            filter then the result of the function depends on the
+            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then
+            the function will return <see cref="F:log4net.Filter.FilterDecision.Accept"/>, it it is false then it
+            will return <see cref="F:log4net.Filter.FilterDecision.Deny"/>. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">
+            <summary>
+            The <see cref="T:log4net.Core.Level"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            The level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LevelRangeFilter">
+            <summary>
+            This is a simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            that determine the range of priorities that are matched, and
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range
+            of priorities and the <see cref="T:log4net.Core.Level"/> of the <see cref="T:log4net.Core.LoggingEvent"/>, then the 
+            <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"/> 
+            option value is set to <c>true</c>, if it is <c>false</c>
+            then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when matching a <see cref="T:log4net.Core.Level"/>
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">
+            <summary>
+            the minimum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">
+            <summary>
+            the maximum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if the event should be logged.
+            </summary>
+            <param name="loggingEvent">the logging event to check</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the logging event is outside the range
+            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            is returned. If the <see cref="T:log4net.Core.Level"/> is matched then the value of
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">
+            <summary>
+            Set the minimum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The minimum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">
+            <summary>
+            Sets the maximum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The maximum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LoggerMatchFilter">
+            <summary>
+            Simple filter to match a string in the event's logger name.
+            </summary>
+            <remarks>
+            <para>
+            The works very similar to the <see cref="T:log4net.Filter.LevelMatchFilter"/>. It admits two 
+            options <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> and <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>. If the 
+            <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <see cref="T:log4net.Core.LoggingEvent"/> starts 
+            with the value of the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> option, then the 
+            <see cref="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in 
+            case the <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> option value is set to <c>true</c>, 
+            if it is <c>false</c> then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_loggerToMatch">
+            <summary>
+            The logger name string to substring match against the event
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>.
+            If the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> equals the beginning of 
+            the incoming <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> (<see cref="M:String.StartsWith(string)"/>)
+            then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch">
+            <summary>
+            The <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            This filter will attempt to match this value against logger name in
+            the following way. The match will be done against the beginning of the
+            logger name (using <see cref="M:String.StartsWith(string)"/>). The match is
+            case sensitive. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.MdcFilter">
+            <summary>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with layered properties the
+            <see cref="T:log4net.Filter.PropertyFilter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.PropertyFilter">
+            <summary>
+            Simple filter to match a string an event property
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the value for a
+            specific event property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Filter.StringMatchFilter">
+            <summary>
+            Simple filter to match a string in the rendered message
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the rendered message
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">
+            <summary>
+            The string to substring match against the message
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">
+            <summary>
+            A string regex to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">
+            <summary>
+            A regex object to match (generated from m_stringRegexToMatch)
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">
+            <summary>
+            Initialize and precompile the Regex if required
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the message then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">
+            <summary>
+            Sets the static string to match
+            </summary>
+            <remarks>
+            <para>
+            The string that will be substring matched against
+            the rendered message. If the message contains this
+            string then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">
+            <summary>
+            Sets the regular expression to match
+            </summary>
+            <remarks>
+            <para>
+            The regular expression pattern that will be matched against
+            the rendered message. If the message matches this
+            pattern then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.PropertyFilter.m_key">
+            <summary>
+            The key to use to lookup the string from the event properties
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The event property for the <see cref="P:log4net.Filter.PropertyFilter.Key"/> is matched against 
+            the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the property value then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.PropertyFilter.Key">
+            <summary>
+            The key to lookup in the event properties and then match against.
+            </summary>
+            <remarks>
+            <para>
+            The key name to use to lookup in the properties map of the
+            <see cref="T:log4net.Core.LoggingEvent"/>. The match will be performed against 
+            the value of this property if it exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.NdcFilter">
+            <summary>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with named stacks stored in the
+            properties collections the <see cref="T:log4net.Filter.PropertyFilter"/> should 
+            be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.NdcFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Sets the <see cref="P:log4net.Filter.PropertyFilter.Key"/> to <c>"NDC"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AppDomainPatternConverter">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Util.PatternConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            <para>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.#ctor">
+            <summary>
+            Protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternConverter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Evaluate this pattern converter and write the output to a writer.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the appropriate way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next pattern converter in the chains
+            </summary>
+            <param name="patternConverter">the pattern converter that should follow this converter in the chain</param>
+            <returns>the next converter</returns>
+            <remarks>
+            <para>
+            The PatternConverter can merge with its neighbor during this method (or a sub class).
+            Therefore the return value may or may not be the value of the argument passed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the pattern converter to the writer with appropriate formatting
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            This method calls <see cref="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)"/> to allow the subclass to perform
+            appropriate conversion of the pattern converter. If formatting options have
+            been specified via the <see cref="P:log4net.Util.PatternConverter.FormattingInfo"/> then this method will
+            apply those formattings before writing the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SpacePad(System.IO.TextWriter,System.Int32)">
+            <summary>
+            Fast space padding method.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> to which the spaces will be appended.</param>
+            <param name="length">The number of spaces to be padded.</param>
+            <remarks>
+            <para>
+            Fast space padding method.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.m_option">
+            <summary>
+            The option string to the converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionary)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionary"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionaryEnumerator)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionaryEnumerator"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteObject(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Object)">
+            <summary>
+            Write an object to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the Object to a writer. If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the object to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Next">
+            <summary>
+            Get the next pattern converter in the chain
+            </summary>
+            <value>
+            the next pattern converter in the chain
+            </value>
+            <remarks>
+            <para>
+            Get the next pattern converter in the chain
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.FormattingInfo">
+            <summary>
+            Gets or sets the formatting info for this converter
+            </summary>
+            <value>
+            The formatting info for this converter
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the formatting info for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Option">
+            <summary>
+            Gets or sets the option value for this converter
+            </summary>
+            <summary>
+            The option for this converter
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the option value for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+        </member>
+        <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">
+            <summary>
+            Flag indicating if this converter handles exceptions
+            </summary>
+            <remarks>
+            <c>false</c> if this converter handles exceptions
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">
+            <summary>
+            Flag indicating if this converter handles the logging event exception
+            </summary>
+            <value><c>false</c> if this converter handles the logging event exception</value>
+            <remarks>
+            <para>
+            If this converter handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the property should be set to <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this converter does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AppDomainPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.DatePatternConverter">
+            <summary>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <remarks>
+            <para>
+            Render the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,yyyy"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Layout.Pattern.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter pattern based on the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ExceptionPatternConverter">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception or the exception property specified
+            by the Option value does not exist then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            <para>
+            Recognized values for the Option parameter are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>Message</description>
+            	</item>
+            	<item>
+            		<description>Source</description>
+            	</item>
+            	<item>
+            		<description>StackTrace</description>
+            	</item>
+            	<item>
+            		<description>TargetSite</description>
+            	</item>
+            	<item>
+            		<description>HelpLink</description>
+            	</item>		
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FileLocationPatternConverter">
+            <summary>
+            Writes the caller location file name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FileLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location file name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FullLocationPatternConverter">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FullLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.IdentityPatternConverter">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.IdentityPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <paramref name="loggingEvent"/> 
+            <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LevelPatternConverter">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LineLocationPatternConverter">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LineLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LoggerPatternConverter">
+            <summary>
+            Converter for logger name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NamedPatternConverter">
+            <summary>
+            Converter to output and truncate <c>'.'</c> separated strings
+            </summary>
+            <remarks>
+            <para>
+            This abstract class supports truncating a <c>'.'</c> separated string
+            to show a specified number of elements from the right hand side.
+            This is used to truncate class names that are fully qualified.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> method to
+            return the fully qualified string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Get the fully qualified string data
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>the fully qualified name</returns>
+            <remarks>
+            <para>
+            Overridden by subclasses to get the fully qualified name before the
+            precision is applied to it.
+            </para>
+            <para>
+            Return the fully qualified <c>'.'</c> (dot/period) separated string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> to the precision
+            specified by the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.NamedPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the NamedPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LoggerPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the logger
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified logger name</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MessagePatternConverter">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MethodLocationPatternConverter">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MethodLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NdcPatternConverter">
+            <summary>
+            Converter to include event NDC
+            </summary>
+            <remarks>
+            <para>
+            Outputs the value of the event property named <c>NDC</c>.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NdcPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event NDC to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            As the thread context stacks are now stored in named event properties
+            this converter simply looks up the value of the <c>NDC</c> property.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PropertyPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">
+            <summary>
+            Converter to output the relative time of the event
+            </summary>
+            <remarks>
+            <para>
+            Converter to output the time of the event relative to the start of the program.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the relative time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the relative time of the event in milliseconds.
+            That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>
+            and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
+            <summary>
+            Helper method to get the time difference between two DateTime objects
+            </summary>
+            <param name="start">start time (in the current local time zone)</param>
+            <param name="end">end time (in the current local time zone)</param>
+            <returns>the time difference in milliseconds</returns>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTraceDetailPatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            </para>
+            </remarks>
+            <author>Adam Davies</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTracePatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            </para>
+            </remarks>
+            <author>Michael Cromwell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the strack frames to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.GetMethodInformation(log4net.Core.MethodItem)">
+            <summary>
+            Returns the Name of the method
+            </summary>
+            <param name="method"></param>
+            <remarks>This method was created, so this class could be used as a base class for StackTraceDetailPatternConverter</remarks>
+            <returns>string</returns>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTracePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTracePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTraceDetailPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTraceDetailPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ThreadPatternConverter">
+            <summary>
+            Converter to include event thread name
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ThreadPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the ThreadName to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.TypeNamePatternConverter">
+            <summary>
+            Pattern converter for the class name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.TypeNamePatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the class
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified type name for the caller location</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UserNamePatternConverter">
+            <summary>
+            Converter to include event user name
+            </summary>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UserNamePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UtcDatePatternConverter">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            Uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> 
+            in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.Pattern.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UtcDatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted
+            to Universal time before it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Layout.Pattern.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.DynamicPatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string that re-evaluates on each call.
+            </summary>
+            <remarks>
+            <para>This class is built on <see cref="T:log4net.Layout.PatternLayout"></see> and provides all the
+            features and capabilities of PatternLayout.  PatternLayout is a 'static' class
+            in that its layout is done once at configuration time.  This class will recreate
+            the layout on each reference.</para>
+            <para>One important difference between PatternLayout and DynamicPatternLayout is the
+            treatment of the Header and Footer parameters in the configuration.  The Header and Footer
+            parameters for DynamicPatternLayout must be syntactically in the form of a PatternString,
+            but should not be marked as type log4net.Util.PatternString.  Doing so causes the
+            pattern to be statically converted at configuration time and causes DynamicPatternLayout
+            to perform the same as PatternLayout.</para>
+            <para>Please see <see cref="T:log4net.Layout.PatternLayout"/> for complete documentation.</para>
+            <example>
+            &lt;layout type="log4net.Layout.DynamicPatternLayout"&gt;
+              &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;
+              &lt;param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;
+            &lt;/layout&gt;
+            </example>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.PatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string.
+            </summary>
+            <remarks>
+            <para>
+            The goal of this class is to <see cref="M:PatternLayout.Format(TextWriter,LoggingEvent)"/> a 
+            <see cref="T:log4net.Core.LoggingEvent"/> as a string. The results
+            depend on the <i>conversion pattern</i>.
+            </para>
+            <para>
+            The conversion pattern is closely related to the conversion
+            pattern of the printf function in C. A conversion pattern is
+            composed of literal text and format control expressions called
+            <i>conversion specifiers</i>.
+            </para>
+            <para>
+            <i>You are free to insert any literal text within the conversion
+            pattern.</i>
+            </para>
+            <para>
+            Each conversion specifier starts with a percent sign (%) and is
+            followed by optional <i>format modifiers</i> and a <i>conversion
+            pattern name</i>. The conversion pattern name specifies the type of
+            data, e.g. logger, level, date, thread name. The format
+            modifiers control such things as field width, padding, left and
+            right justification. The following is a simple example.
+            </para>
+            <para>
+            Let the conversion pattern be <b>"%-5level [%thread]: %message%newline"</b> and assume
+            that the log4net environment was set to use a PatternLayout. Then the
+            statements
+            </para>
+            <code lang="C#">
+            ILog log = LogManager.GetLogger(typeof(TestApp));
+            log.Debug("Message 1");
+            log.Warn("Message 2");   
+            </code>
+            <para>would yield the output</para>
+            <code>
+            DEBUG [main]: Message 1
+            WARN  [main]: Message 2  
+            </code>
+            <para>
+            Note that there is no explicit separator between text and
+            conversion specifiers. The pattern parser knows when it has reached
+            the end of a conversion specifier when it reads a conversion
+            character. In the example above the conversion specifier
+            <b>%-5level</b> means the level of the logging event should be left
+            justified to a width of five characters.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>a</term>
+                    <description>Equivalent to <b>appdomain</b></description>
+                </item>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+            			Used to output the friendly name of the AppDomain where the 
+            			logging event was generated. 
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-cache</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-context</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-request</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-session</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>c</term>
+                    <description>Equivalent to <b>logger</b></description>
+                </item>
+                <item>
+                    <term>C</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>class</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>d</term>
+                    <description>Equivalent to <b>date</b></description>
+                </item>
+                <item>
+            		<term>date</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>exception</term>
+            		<description>
+            			<para>
+            			Used to output the exception passed in with the log message.
+            			</para>
+            			<para>
+            			If an exception object is stored in the logging event
+            			it will be rendered into the pattern output with a
+            			trailing newline.
+            			If there is no exception then nothing will be output
+            			and no trailing newline will be appended.
+            			It is typical to put a newline before the exception
+            			and to have the exception as the last data in the pattern.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>F</term>
+                    <description>Equivalent to <b>file</b></description>
+                </item>
+            	<item>
+            		<term>file</term>
+            		<description>
+            			<para>
+            			Used to output the file name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>identity</term>
+            		<description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>l</term>
+                    <description>Equivalent to <b>location</b></description>
+                </item>
+                <item>
+                    <term>L</term>
+                    <description>Equivalent to <b>line</b></description>
+                </item>
+            	<item>
+            		<term>location</term>
+            		<description>
+            			<para>
+            			Used to output location information of the caller which generated
+            			the logging event.
+            			</para>
+            			<para>
+            			The location information depends on the CLI implementation but
+            			usually consists of the fully qualified name of the calling
+            			method followed by the callers source the file name and line
+            			number between parentheses.
+            			</para>
+            			<para>
+            			The location information can be very useful. However, its
+            			generation is <b>extremely</b> slow. Its use should be avoided
+            			unless execution speed is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>level</term>
+            		<description>
+            			<para>
+            			Used to output the level of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>line</term>
+            		<description>
+            			<para>
+            			Used to output the line number from where the logging request
+            			was issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>logger</term>
+                    <description>
+                        <para>
+            			Used to output the logger of the logging event. The
+            			logger conversion specifier can be optionally followed by
+            			<i>precision specifier</i>, that is a decimal constant in
+            			brackets.
+                        </para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the logger name will be
+            			printed. By default the logger name is printed in full.
+            			</para>
+            			<para>
+            			For example, for the logger name "a.b.c" the pattern
+            			<b>%logger{2}</b> will output "b.c".
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>m</term>
+                    <description>Equivalent to <b>message</b></description>
+                </item>
+                <item>
+                    <term>M</term>
+                    <description>Equivalent to <b>method</b></description>
+                </item>
+            	<item>
+            		<term>message</term>
+            		<description>
+            			<para>
+            			Used to output the application supplied message associated with 
+            			the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>mdc</term>
+            		<description>
+            			<para>
+            			The MDC (old name for the ThreadContext.Properties) is now part of the
+            			combined event properties. This pattern is supported for compatibility
+            			but is equivalent to <b>property</b>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>method</term>
+            		<description>
+            			<para>
+            			Used to output the method name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>n</term>
+                    <description>Equivalent to <b>newline</b></description>
+                </item>
+            	<item>
+            		<term>newline</term>
+            		<description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+            		</description>
+            	</item>
+            	<item>
+            		<term>ndc</term>
+            		<description>
+            			<para>
+            			Used to output the NDC (nested diagnostic context) associated
+            			with the thread that generated the logging event.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>p</term>
+                    <description>Equivalent to <b>level</b></description>
+                </item>
+                <item>
+                    <term>P</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+                <item>
+                    <term>properties</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+            	<item>
+            		<term>property</term>
+            		<description>
+            			<para>
+            			Used to output the an event specific property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are added to events by loggers or appenders. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the event properties</term>
+            					<description>
+            					The event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            					properties are specific to this event only.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+            			
+            		</description>
+            	</item>
+                <item>
+                    <term>r</term>
+                    <description>Equivalent to <b>timestamp</b></description>
+                </item>
+            	<item>
+            		<term>stacktrace</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktrace{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+            			type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>stacktracedetail</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktracedetail{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+                        type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+                <item>
+                    <term>t</term>
+                    <description>Equivalent to <b>thread</b></description>
+                </item>
+            	<item>
+            		<term>timestamp</term>
+            		<description>
+            			<para>
+            			Used to output the number of milliseconds elapsed since the start
+            			of the application until the creation of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>thread</term>
+            		<description>
+            			<para>
+            			Used to output the name of the thread that generated the
+            			logging event. Uses the thread number if no name is available.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>type</term> 
+            		<description>
+            			<para>
+            			Used to output the fully qualified type name of the caller
+            			issuing the logging request. This conversion specifier
+            			can be optionally followed by <i>precision specifier</i>, that
+            			is a decimal constant in brackets.
+            			</para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the class name will be
+            			printed. By default the class name is output in fully qualified form.
+            			</para>
+            			<para>
+            			For example, for the class name "log4net.Layout.PatternLayout", the
+            			pattern <b>%type{1}</b> will output "PatternLayout".
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating the caller class information is
+            			slow. Thus, its use should be avoided unless execution speed is
+            			not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+                </item>
+                <item>
+                    <term>u</term>
+                    <description>Equivalent to <b>identity</b></description>
+                </item>
+            	<item>
+            		<term>username</term>
+            		<description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller WindowsIdentity information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>utcdate</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>w</term>
+                    <description>Equivalent to <b>username</b></description>
+                </item>
+                <item>
+                    <term>x</term>
+                    <description>Equivalent to <b>ndc</b></description>
+                </item>
+                <item>
+                    <term>X</term>
+                    <description>Equivalent to <b>mdc</b></description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            The single letter patterns are deprecated in favor of the 
+            longer more descriptive pattern names.
+            </para>
+            <para>
+            By default the relevant information is output as is. However,
+            with the aid of format modifiers it is possible to change the
+            minimum field width, the maximum field width and justification.
+            </para>
+            <para>
+            The optional format modifier is placed between the percent sign
+            and the conversion pattern name.
+            </para>
+            <para>
+            The first optional format modifier is the <i>left justification
+            flag</i> which is just the minus (-) character. Then comes the
+            optional <i>minimum field width</i> modifier. This is a decimal
+            constant that represents the minimum number of characters to
+            output. If the data item requires fewer characters, it is padded on
+            either the left or the right until the minimum width is
+            reached. The default is to pad on the left (right justify) but you
+            can specify right padding with the left justification flag. The
+            padding character is space. If the data item is larger than the
+            minimum field width, the field is expanded to accommodate the
+            data. The value is never truncated.
+            </para>
+            <para>
+            This behavior can be changed using the <i>maximum field
+            width</i> modifier which is designated by a period followed by a
+            decimal constant. If the data item is longer than the maximum
+            field, then the extra characters are removed from the
+            <i>beginning</i> of the data item and not from the end. For
+            example, it the maximum field width is eight and the data item is
+            ten characters long, then the first two characters of the data item
+            are dropped. This behavior deviates from the printf function in C
+            where truncation is done from the end.
+            </para>
+            <para>
+            Below are various format modifier examples for the logger
+            conversion specifier.
+            </para>
+            <div class="tablediv">
+            	<table class="dtTABLE" cellspacing="0">
+            		<tr>
+            			<th>Format modifier</th>
+            			<th>left justify</th>
+            			<th>minimum width</th>
+            			<th>maximum width</th>
+            			<th>comment</th>
+            		</tr>
+            		<tr>
+            			<td align="center">%20logger</td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is less than 20
+            				characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger 
+            				name is less than 20 characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%.30logger</td>
+            			<td align="center">NA</td>
+            			<td align="center">none</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Truncate from the beginning if the logger 
+            				name is longer than 30 characters.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center"><nobr>%20.30logger</nobr></td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20.30logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            	</table>
+            </div>
+            <para>
+            <b>Note about caller location information.</b><br/>
+            The following patterns <c>%type %file %line %method %location %class %C %F %L %l %M</c> 
+            all generate caller location information.
+            Location information uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            </note>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </note>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Layout.PatternLayout"/>
+            instance using the <see cref="M:AddConverter(string, Type)"/> method.
+            </para>
+            </remarks>
+            <example>
+            This is a more detailed pattern.
+            <code><b>%timestamp [%thread] %level %logger %ndc - %message%newline</b></code>
+            </example>
+            <example>
+            A similar pattern except that the relative time is
+            right padded if less than 6 digits, thread name is right padded if
+            less than 15 characters and truncated if longer and the logger
+            name is left padded if shorter than 30 characters and truncated if
+            longer.
+            <code><b>%-6timestamp [%15.15thread] %-5level %30.30logger %ndc - %message%newline</b></code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="T:log4net.Layout.LayoutSkeleton">
+            <summary>
+            Extend this abstract class to create your own log layout format.
+            </summary>
+            <remarks>
+            <para>
+            This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
+            interface. Most layout objects should extend this class.
+            </para>
+            </remarks>
+            <remarks>
+            <note type="inheritinfo">
+            <para>
+            Subclasses must implement the <see cref="M:Format(TextWriter,LoggingEvent)"/>
+            method.
+            </para>
+            <para>
+            Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default
+            constructor.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.ILayout">
+            <summary>
+            Interface implemented by layout objects
+            </summary>
+            <remarks>
+            <para>
+            An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            as text. The <see cref="M:Format(TextWriter,LoggingEvent)"/> method is called by an
+            appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.
+            </para>
+            <para>
+            The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            text that is appender before any events and after all the events respectively.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text and output to a writer.
+            </para>
+            <para>
+            If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the
+            event to be formatted as a <see cref="T:System.String"/> then the following
+            code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.
+            </para>
+            <code lang="C#">
+            StringWriter writer = new StringWriter();
+            Layout.Format(writer, loggingEvent);
+            string formattedEvent = writer.ToString();
+            </code>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type</value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This is a MIME type e.g. <c>"text/plain"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.IgnoresException">
+            <summary>
+            Flag indicating if this layout handle exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_header">
+            <summary>
+            The header text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
+            <summary>
+            The footer text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <remarks>
+            <para>
+            <c>false</c> if this layout handles exceptions
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
+            <summary>
+            Empty default constructor
+            </summary>
+            <remarks>
+            <para>
+            Empty default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This method must be implemented by the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Convenience method for easily formatting the logging event into a string variable.
+            </summary>
+            <param name="loggingEvent"></param>
+            <remarks>
+            Creates a new StringWriter instance to store the formatted logging event.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type is <c>"text/plain"</c></value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This base class uses the value <c>"text/plain"</c>.
+            To change this value a subclass must override this
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this layout does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DefaultConversionPattern">
+            <summary>
+            Default pattern string for log output. 
+            </summary>
+            <remarks>
+            <para>
+            Default pattern string for log output. 
+            Currently set to the string <b>"%message%newline"</b> 
+            which just prints the application supplied message. 
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DetailConversionPattern">
+            <summary>
+            A detailed conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            A conversion pattern which includes Time, Thread, Logger, and Nested Context.
+            Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+            <remarks>
+            <para>
+            This static map is overridden by the m_converterRegistry instance map
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternLayout only
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+            <remarks>
+            <para>
+            Defines the builtin global rules.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor">
+            <summary>
+            Constructs a PatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            As per the <see cref="T:log4net.Core.IOptionHandler"/> contract the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>
+            method must be called after the properties on this object have been
+            configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a PatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            When using this constructor the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method 
+            need not be called. This may not be the case when using a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">
+            <summary>
+            Create the pattern parser instance
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/> that will format the event</returns>
+            <remarks>
+            <para>
+            Creates the <see cref="T:log4net.Util.PatternParser"/> used to parse the conversion string. Sets the
+            global and instance rules on the <see cref="T:log4net.Util.PatternParser"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Parse the <see cref="T:log4net.Core.LoggingEvent"/> using the patter format
+            specified in the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a named pattern converter to this instance. This
+            converter will be used in the formatting of the event.
+            This method must be called before <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>.
+            </para>
+            <para>
+            The <paramref name="type"/> specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">
+            <summary>
+            The pattern formatting string
+            </summary>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_headerPatternString">
+            <summary>
+            The header PatternString
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_footerPatternString">
+            <summary>
+            The footer PatternString
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor">
+            <summary>
+            Constructs a DynamicPatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a DynamicPatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.ExceptionLayout">
+            <summary>
+            A Layout that renders only the Exception text from the logging event
+            </summary>
+            <remarks>
+            <para>
+            A Layout that renders only the Exception text from the logging event.
+            </para>
+            <para>
+            This Layout should only be used with appenders that utilize multiple
+            layouts (e.g. <see cref="T:log4net.Appender.AdoNetAppender"/>).
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Constructs a ExceptionLayout
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            Part of the <see cref="T:log4net.Core.IOptionHandler"/> component activation
+            framework.
+            </para>
+            <para>
+            This method does nothing as options become effective immediately.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the exception text from the logging event
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Write the exception string to the <see cref="T:System.IO.TextWriter"/>.
+            The exception string is retrieved from <see cref="M:LoggingEvent.GetExceptionString()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.IRawLayout">
+            <summary>
+            Interface for raw layout objects
+            </summary>
+            <remarks>
+            <para>
+            Interface used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            to an object.
+            </para>
+            <para>
+            This interface should not be confused with the
+            <see cref="T:log4net.Layout.ILayout"/> interface. This interface is used in
+            only certain specialized situations where a raw object is
+            required rather than a formatted string. The <see cref="T:log4net.Layout.ILayout"/>
+            is not generally useful than this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.IRawLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Implement this method to create your own layout format.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Layout2RawLayoutAdapter">
+            <summary>
+            Adapts any <see cref="T:log4net.Layout.ILayout"/> to a <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <remarks>
+            <para>
+            Where an <see cref="T:log4net.Layout.IRawLayout"/> is required this adapter
+            allows a <see cref="T:log4net.Layout.ILayout"/> to be specified.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Layout.Layout2RawLayoutAdapter.m_layout">
+            <summary>
+            The layout to adapt
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Construct a new adapter
+            </summary>
+            <param name="layout">the layout to adapt</param>
+            <remarks>
+            <para>
+            Create the adapter for the specified <paramref name="layout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Format the logging event as an object.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Format the logging event as an object.
+            </para>
+            <para>
+            Uses the <see cref="T:log4net.Layout.ILayout"/> object supplied to 
+            the constructor to perform the formatting.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawLayoutConverter">
+            <summary>
+            Type converter for the <see cref="T:log4net.Layout.IRawLayout"/> interface
+            </summary>
+            <remarks>
+            <para>
+            Used to convert objects to the <see cref="T:log4net.Layout.IRawLayout"/> interface.
+            Supports converting from the <see cref="T:log4net.Layout.ILayout"/> interface to
+            the <see cref="T:log4net.Layout.IRawLayout"/> interface using the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertFrom">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from arbitrary types
+            to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to the
+            type supported by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> to the type supported
+            by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the sourceType be converted to an <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <param name="sourceType">the source to be to be converted</param>
+            <returns><c>true</c> if the source type can be converted to <see cref="T:log4net.Layout.IRawLayout"/></returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to a
+            <see cref="T:log4net.Layout.IRawLayout"/>. Only <see cref="T:log4net.Layout.ILayout"/> is supported
+            as the <paramref name="sourceType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the value to a <see cref="T:log4net.Layout.IRawLayout"/> object
+            </summary>
+            <param name="source">the value to convert</param>
+            <returns>the <see cref="T:log4net.Layout.IRawLayout"/> object</returns>
+            <remarks>
+            <para>
+            Convert the <paramref name="source"/> object to a 
+            <see cref="T:log4net.Layout.IRawLayout"/> object. If the <paramref name="source"/> object
+            is a <see cref="T:log4net.Layout.ILayout"/> then the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>
+            is used to adapt between the two interfaces, otherwise an
+            exception is thrown.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawPropertyLayout">
+            <summary>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.#ctor">
+            <summary>
+            Constructs a RawPropertyLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Lookup the property for <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns property value</returns>
+            <remarks>
+            <para>
+            Looks up and returns the object value of the property
+            named <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>. If there is no property defined
+            with than name then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.RawPropertyLayout.Key">
+            <summary>
+            The name of the value to lookup in the LoggingEvent Properties collection.
+            </summary>
+            <value>
+            Value to lookup in the LoggingEvent Properties collection
+            </value>
+            <remarks>
+            <para>
+            String name of the property to lookup in the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in local time. To format the time stamp
+            in universal time use <see cref="T:log4net.Layout.RawUtcTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawUtcTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawUtcTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in universal time. To format the time stamp
+            in local time use <see cref="T:log4net.Layout.RawTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.SimpleLayout">
+            <summary>
+            A very simple layout
+            </summary>
+            <remarks>
+            <para>
+            SimpleLayout consists of the level of the log statement,
+            followed by " - " and then the log message itself. For example,
+            <code>
+            DEBUG - Hello world
+            </code>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.#ctor">
+            <summary>
+            Constructs a SimpleLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a simple formatted output.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Formats the event as the level of the even,
+            followed by " - " and then the log message itself. The
+            output is terminated by a newline.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayout">
+             <summary>
+             Layout that formats the log events as XML elements.
+             </summary>
+             <remarks>
+             <para>
+             The output of the <see cref="T:log4net.Layout.XmlLayout"/> consists of a series of 
+             log4net:event elements. It does not output a complete well-formed XML 
+             file. The output is designed to be included as an <em>external entity</em>
+             in a separate file to form a correct XML file.
+             </para>
+             <para>
+             For example, if <c>abc</c> is the name of the file where
+             the <see cref="T:log4net.Layout.XmlLayout"/> output goes, then a well-formed XML file would 
+             be:
+             </para>
+             <code lang="XML">
+             &lt;?xml version="1.0" ?&gt;
+             
+             &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;
+            
+             &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;
+                 &amp;data;
+             &lt;/log4net:events&gt;
+             </code>
+             <para>
+             This approach enforces the independence of the <see cref="T:log4net.Layout.XmlLayout"/> 
+             and the appender where it is embedded.
+             </para>
+             <para>
+             The <c>version</c> attribute helps components to correctly
+             interpret output generated by <see cref="T:log4net.Layout.XmlLayout"/>. The value of 
+             this attribute should be "1.2" for release 1.2 and later.
+             </para>
+             <para>
+             Alternatively the <c>Header</c> and <c>Footer</c> properties can be
+             configured to output the correct XML header, open tag and close tag.
+             When setting the <c>Header</c> and <c>Footer</c> properties it is essential
+             that the underlying data store not be appendable otherwise the data
+             will become invalid XML.
+             </para>
+             </remarks>
+             <author>Nicko Cadell</author>
+             <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutBase">
+            <summary>
+            Layout that formats the log events as XML elements.
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract class that must be subclassed by an implementation 
+            to conform to a specific schema.
+            </para>
+            <para>
+            Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class
+            with no location info.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="locationInfo" /> parameter determines whether 
+            location information will be output by the layout. If 
+            <paramref name="locationInfo" /> is set to <c>true</c>, then the 
+            file name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the
+            <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed 
+            to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the
+            <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to format
+            the <see cref="T:log4net.Core.LoggingEvent"/> as XML.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">
+            <summary>
+            Flag to indicate if location information should be included in
+            the XML events.
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">
+            <summary>
+            The string to replace invalid chars with
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">
+            <summary>
+            Gets a value indicating whether to include location information in 
+            the XML events.
+            </summary>
+            <value>
+            <c>true</c> if location information should be included in the XML 
+            events; otherwise, <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file 
+            name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an <c>SMTPAppender</c>
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">
+            <summary>
+            The string to replace characters that can not be expressed in XML with.
+            <remarks>
+            <para>
+            Not all characters may be expressed in XML. This property contains the
+            string to replace those that can not with. This defaults to a ?. Set it
+            to the empty string to simply remove offending characters. For more
+            details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets
+            Character replacement will occur in  the log message, the property names 
+            and the property values.
+            </para>
+            </remarks>
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.ContentType">
+            <summary>
+            Gets the content type output by this layout. 
+            </summary>
+            <value>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </value>
+            <remarks>
+            <para>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor">
+            <summary>
+            Constructs an XmlLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XmlLayout.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SmtpAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Builds a cache of the element names
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Override the base class <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method
+            to write the <see cref="T:log4net.Core.LoggingEvent"/> to the <see cref="T:System.Xml.XmlWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayout.m_prefix">
+            <summary>
+            The prefix to use for all generated element names
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Prefix">
+            <summary>
+            The prefix to use for all element names
+            </summary>
+            <remarks>
+            <para>
+            The default prefix is <b>log4net</b>. Set this property
+            to change the prefix. If the prefix is set to an empty string
+            then no prefix will be written.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeMessage">
+            <summary>
+            Set whether or not to base64 encode the message.
+            </summary>
+            <remarks>
+            <para>
+            By default the log message will be written as text to the xml
+            output. This can cause problems when the message contains binary
+            data. By setting this to true the contents of the message will be
+            base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the log message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeProperties">
+            <summary>
+            Set whether or not to base64 encode the property values.
+            </summary>
+            <remarks>
+            <para>
+            By default the properties will be written as text to the xml
+            output. This can cause problems when one or more properties contain
+            binary data. By setting this to true the values of the properties
+            will be base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the property values.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutSchemaLog4j">
+            <summary>
+            Layout that formats the log events as XML elements compatible with the log4j schema
+            </summary>
+            <remarks>
+            <para>
+            Formats the log events according to the http://logging.apache.org/log4j schema.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutSchemaLog4j.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Actually do the writing of the xml
+            </summary>
+            <param name="writer">the writer to use</param>
+            <param name="loggingEvent">the event to write</param>
+            <remarks>
+            <para>
+            Generate XML that is compatible with the log4j schema.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutSchemaLog4j.Version">
+            <summary>
+            The version of the log4j schema to use.
+            </summary>
+            <remarks>
+            <para>
+            Only version 1.2 of the log4j schema is supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.DefaultRenderer">
+            <summary>
+            The default object Renderer.
+            </summary>
+            <remarks>
+            <para>
+            The default renderer supports rendering objects and collections to strings.
+            </para>
+            <para>
+            See the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)"/> method for details of the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ObjectRenderer.IObjectRenderer">
+            <summary>
+            Implement this interface in order to render objects as strings
+            </summary>
+            <remarks>
+            <para>
+            Certain types require special case conversion to
+            string form. This conversion is done by an object renderer.
+            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>
+            interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.IObjectRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a 
+            string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object, TextWriter)"/>
+            method can be used to render these objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)"/>
+            method can be used to render these objects.
+            </para>
+            <para>
+            The default renderer supports rendering objects to strings as follows:
+            </para>
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Rendered String</description>
+            	</listheader>
+            	<item>
+            		<term><c>null</c></term>
+            		<description>
+            		<para>"(null)"</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Array"/></term>
+            		<description>
+            		<para>
+            		For a one dimensional array this is the
+            		array type name, an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace. 
+            		</para>
+            		<para>
+            		For example: <c>int[] {1, 2, 3}</c>.
+            		</para>
+            		<para>
+            		If the array is not one dimensional the 
+            		<c>Array.ToString()</c> is returned.
+            		</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Collections.IEnumerable"/>, <see cref="T:System.Collections.ICollection"/> &amp; <see cref="T:System.Collections.IEnumerator"/></term>
+            		<description>
+            		<para>
+            		Rendered as an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace.
+            		</para>
+            		<para>
+            		For example: <c>{a, b, c}</c>.
+            		</para>
+            		<para>
+            		All collection classes that implement <see cref="T:System.Collections.ICollection"/> its subclasses, 
+            		or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable"/> interface.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term><see cref="T:System.Collections.DictionaryEntry"/></term>
+            		<description>
+            		<para>
+            		Rendered as the key, an equals sign ('='), and the value (using the appropriate
+            		renderer). 
+            		</para>
+            		<para>
+            		For example: <c>key=value</c>.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term>other</term>
+            		<description>
+            		<para><c>Object.ToString()</c></para>
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array,System.IO.TextWriter)">
+            <summary>
+            Render the array argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="array">the array to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            For a one dimensional array this is the
+            array type name, an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>int[] {1, 2, 3}</c>.
+            </para>
+            <para>
+            If the array is not one dimensional the 
+            <c>Array.ToString()</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderEnumerator(log4net.ObjectRenderer.RendererMap,System.Collections.IEnumerator,System.IO.TextWriter)">
+            <summary>
+            Render the enumerator argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="enumerator">the enumerator to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Rendered as an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>{a, b, c}</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderDictionaryEntry(log4net.ObjectRenderer.RendererMap,System.Collections.DictionaryEntry,System.IO.TextWriter)">
+            <summary>
+            Render the DictionaryEntry argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="entry">the DictionaryEntry to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the key, an equals sign ('='), and the value (using the appropriate
+            renderer). For example: <c>key=value</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.RendererMap">
+            <summary>
+            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a mapping between types that require special
+            rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that
+            is used to render them.
+            </para>
+            <para>
+            The <see cref="M:FindAndRender(object)"/> method is used to render an
+            <c>object</c> using the appropriate renderers defined in this map.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <returns>the object rendered as a string</returns>
+            <remarks>
+            <para>
+            This is a convenience method used to render an object to a string.
+            The alternative method <see cref="M:FindAndRender(object,TextWriter)"/>
+            should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Find the appropriate renderer for the type of the
+            <paramref name="obj"/> parameter. This is accomplished by calling the
+            <see cref="M:Get(Type)"/> method. Once a renderer is found, it is
+            applied on the object <paramref name="obj"/> and the result is returned
+            as a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
+            <summary>
+            Gets the renderer for the specified object type
+            </summary>
+            <param name="obj">the object to lookup the renderer for</param>
+            <returns>the renderer for <paramref name="obj"/></returns>
+            <remarks>
+            <param>
+            Gets the renderer for the specified object type.
+            </param>
+            <param>
+            Syntactic sugar method that calls <see cref="M:Get(Type)"/> 
+            with the type of the object parameter.
+            </param>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
+            <summary>
+            Gets the renderer for the specified type
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+            <remarks>
+            <para>
+            Returns the renderer for the specified type.
+            If no specific renderer has been defined the
+            <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">
+            <summary>
+            Internal function to recursively search interfaces
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
+            <summary>
+            Clear the map of renderers
+            </summary>
+            <remarks>
+            <para>
+            Clear the custom renderers defined by using
+            <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>
+            cannot be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>. 
+            </summary>
+            <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>
+            <param name="renderer">the renderer for <paramref name="typeToRender"/></param>
+            <remarks>
+            <para>
+            Register an object renderer for a specific source type.
+            This renderer will be returned from a call to <see cref="M:Get(Type)"/>
+            specifying the same <paramref name="typeToRender"/> as an argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
+            <summary>
+            Get the default renderer instance
+            </summary>
+            <value>the default renderer</value>
+            <remarks>
+            <para>
+            Get the default renderer
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.IPlugin">
+            <summary>
+            Interface implemented by logger repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            Plugins define additional behavior that can be associated
+            with a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The <see cref="T:log4net.Plugin.PluginMap"/> held by the <see cref="P:log4net.Repository.ILoggerRepository.PluginMap"/>
+            property is used to store the plugins for a repository.
+            </para>
+            <para>
+            The <c>log4net.Config.PluginAttribute</c> can be used to
+            attach plugins to repositories created using configuration
+            attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches the plugin to the specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.IPlugin.Name">
+            <summary>
+            Gets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ReadOnly(log4net.Plugin.PluginCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>PluginCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>PluginCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>PluginCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <c>PluginCollection</c>.
+            </summary>
+            <param name="c">The <c>PluginCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.IPlugin[])">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[])">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[],System.Int32)">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the end of the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to be added to the end of the <c>PluginCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clear">
+            <summary>
+            Removes all elements from the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Plugin.PluginCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Contains(log4net.Plugin.IPlugin)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Plugin.IPlugin"/> is in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>PluginCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IndexOf(log4net.Plugin.IPlugin)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Plugin.IPlugin"/>
+            in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to locate in the <c>PluginCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>PluginCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Insert(System.Int32,log4net.Plugin.IPlugin)">
+            <summary>
+            Inserts an element into the <c>PluginCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Plugin.IPlugin"/> from the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the <c>PluginCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Plugin.IPlugin"/> was not found in the <c>PluginCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>PluginCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>PluginCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Plugin.PluginCollection.Enumerator"/> for the entire <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.PluginCollection)">
+            <summary>
+            Adds the elements of another <c>PluginCollection</c> to the current <c>PluginCollection</c>.
+            </summary>
+            <param name="x">The <c>PluginCollection</c> whose elements should be added to the end of the current <c>PluginCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.IPlugin[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> array to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> collection to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the collection.
+            </value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </value>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value><c>true</c> if the collection has a fixed size; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value><c>true</c> if the collection is read-only; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>PluginCollection</c> can contain.
+            </summary>
+            <value>
+            The number of elements the <c>PluginCollection</c> can contain.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Plugin.PluginCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+            <value>
+            The current element in the collection.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.ReadOnlyPluginCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Plugin.PluginMap">
+            <summary>
+            Map of repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            This class is a name keyed map of the plugins that are
+            attached to a repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository that the plugins should be attached to.</param>
+            <remarks>
+            <para>
+            Initialize a new instance of the <see cref="T:log4net.Plugin.PluginMap"/> class with a 
+            repository that the plugins should be attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to add to the map.</param>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Plugin.IPlugin"/> will be attached to the repository when added.
+            </para>
+            <para>
+            If there already exists a plugin with the same name 
+            attached to the repository then the old plugin will
+            be <see cref="M:log4net.Plugin.IPlugin.Shutdown"/> and replaced with
+            the new plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes a <see cref="T:log4net.Plugin.IPlugin"/> from the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the map.</param>
+            <remarks>
+            <para>
+            Remove a specific plugin from this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.Item(System.String)">
+            <summary>
+            Gets a <see cref="T:log4net.Plugin.IPlugin"/> by name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Plugin.IPlugin"/> to lookup.</param>
+            <returns>
+            The <see cref="T:log4net.Plugin.IPlugin"/> from the map with the name specified, or 
+            <c>null</c> if no plugin is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup a plugin by name. If the plugin is not found <c>null</c>
+            will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.AllPlugins">
+            <summary>
+            Gets all possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <value>All possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.</value>
+            <remarks>
+            <para>
+            Get a collection of all the plugins defined in this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginSkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Plugin.IPlugin"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Plugin.IPlugin"/>
+            interface. This base class can be used by implementors
+            of the <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="name">the name of the plugin</param>
+            <remarks>
+            Initializes a new Plugin with the specified name.
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_name">
+            <summary>
+            The name of this plugin.
+            </summary>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_repository">
+            <summary>
+            The repository this plugin is attached to.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.Name">
+            <summary>
+            Gets or sets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            <para>
+            The name of the plugin must not change one the 
+            plugin has been attached to a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.LoggerRepository">
+            <summary>
+            The repository for this plugin
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is attached to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is 
+            attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin">
+            <summary>
+            Plugin that listens for events from the <see cref="T:log4net.Appender.RemotingAppender"/>
+            </summary>
+            <remarks>
+            <para>
+            This plugin publishes an instance of <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/> 
+            on a specified <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/>. This listens for logging events delivered from
+            a remote <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            <para>
+            When an event is received it is relogged within the attached repository
+            as if it had been raised locally.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class.
+            </para>
+            <para>
+            The <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> property must be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor(System.String)">
+            <summary>
+            Construct with sink Uri.
+            </summary>
+            <param name="sinkUri">The name to publish the sink under in the remoting infrastructure. 
+            See <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> for more details.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class
+            with specified name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            When the plugin is shutdown the remote logging
+            sink is disconnected.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.declaringType">
+            <summary>
+            The fully qualified type of the RemoteLoggingServerPlugin class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri">
+            <summary>
+            Gets or sets the URI of this sink.
+            </summary>
+            <value>
+            The URI of this sink.
+            </value>
+            <remarks>
+            <para>
+            This is the name under which the object is marshaled.
+            <see cref="M:RemotingServices.Marshal(MarshalByRefObject,String,Type)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl">
+            <summary>
+            Delivers <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to listen for logging events
+            and deliver them to the local repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository to log to.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl"/> for the
+            specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Logs the events to the repository.
+            </summary>
+            <param name="events">The events to log.</param>
+            <remarks>
+            <para>
+            The events passed are logged to the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.InitializeLifetimeService">
+            <summary>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance.
+            </summary>
+            <returns><c>null</c> to indicate that this instance should live forever.</returns>
+            <remarks>
+            <para>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance. This object should live forever
+            therefore this implementation returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.m_repository">
+            <summary>
+            The underlying <see cref="T:log4net.Repository.ILoggerRepository"/> that events should
+            be logged to.
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">
+            <summary>
+            Default implementation of <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            </summary>
+            <remarks>
+            <para>
+            This default implementation of the <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            interface is used to create the default subclass
+            of the <see cref="T:log4net.Repository.Hierarchy.Logger"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">
+            <summary>
+            Interface abstracts creation of <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances
+            </summary>
+            <remarks>
+            <para>
+            This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to 
+            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.
+            </para>
+            <para>
+            The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)"/> method is called
+            to create a named <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            <para>
+            Implement this interface to create new subclasses of <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl">
+            <summary>
+            Default internal subclass of <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            </summary>
+            <remarks>
+            <para>
+            This subclass has no additional behavior over the
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> class but does allow instances
+            to be created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Logger">
+            <summary>
+            Implementation of <see cref="T:log4net.Core.ILogger"/> used by <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to provide implementation of <see cref="T:log4net.Core.ILogger"/>
+            interface. Applications should use <see cref="T:log4net.LogManager"/> to get
+            logger instances.
+            </para>
+            <para>
+            This is one of the central classes in the log4net implementation. One of the
+            distinctive features of log4net are hierarchical loggers and their
+            evaluation. The <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> organizes the <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            instances into a rooted tree hierarchy.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.Logger"/> class is abstract. Only concrete subclasses of
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> can be created. The <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            is used to create instances of this type for the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">
+            <summary>
+            This constructor created a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance and
+            sets its name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <remarks>
+            <para>
+            This constructor is protected and designed to be used by
+            a subclass that is not abstract.
+            </para>
+            <para>
+            Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> 
+            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default
+            logger creator.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </summary>
+            <param name="newAppender">An appender to add to this logger</param>
+            <remarks>
+            <para>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </para>
+            <para>
+            If <paramref name="newAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">
+            <summary>
+            Look for the appender named as <c>name</c>
+            </summary>
+            <param name="name">The name of the appender to lookup</param>
+            <returns>The appender with the name specified, or <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Returns the named appender, or null if the appender is not found.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">
+            <summary>
+            Remove all previously added appenders from this Logger instance.
+            </summary>
+            <remarks>
+            <para>
+            Remove all previously added appenders from this Logger instance.
+            </para>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the named appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Deliver the <see cref="T:log4net.Core.LoggingEvent"/> to the attached appenders.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Call the appenders in the hierarchy starting at
+            <c>this</c>. If no appenders could be found, emit a
+            warning.
+            </para>
+            <para>
+            This method calls all the appenders inherited from the
+            hierarchy circumventing any evaluation of whether to log or not
+            to log the particular log request.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">
+            <summary>
+            Closes all attached appenders implementing the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Used to ensure that the appenders are correctly shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This is the most generic printing method. This generic form is intended to be used by wrappers
+            </summary>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generates a logging event and delivers it to the attached
+            appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.Core.LoggingEvent)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">
+            <summary>
+            The name of this logger.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">
+            <summary>
+            The assigned level of this logger. 
+            </summary>
+            <remarks>
+            <para>
+            The <c>level</c> variable need not be 
+            assigned a value in which case it is inherited 
+            form the hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">
+            <summary>
+            The parent of this logger.
+            </summary>
+            <remarks>
+            <para>
+            The parent of this logger. 
+            All loggers have at least one ancestor which is the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">
+            <summary>
+            Loggers need to know what Hierarchy they are in.
+            </summary>
+            <remarks>
+            <para>
+            Loggers need to know what Hierarchy they are in.
+            The hierarchy that this logger is a member of is stored
+            here.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderAttachedImpl">
+            <summary>
+            Helper implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">
+            <summary>
+            Flag indicating if child loggers inherit their parents appenders
+            </summary>
+            <remarks>
+            <para>
+            Additivity is set to true by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderLock">
+            <summary>
+            Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl
+            </summary>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">
+            <summary>
+            Gets or sets the parent logger in the hierarchy.
+            </summary>
+            <value>
+            The parent logger in the hierarchy.
+            </value>
+            <remarks>
+            <para>
+            Part of the Composite pattern that makes the hierarchy.
+            The hierarchy is parent linked rather than child linked.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">
+            <summary>
+            Gets or sets a value indicating if child loggers inherit their parent's appenders.
+            </summary>
+            <value>
+            <c>true</c> if child loggers inherit their parent's appenders.
+            </value>
+            <remarks>
+            <para>
+            Additivity is set to <c>true</c> by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.EffectiveLevel">
+            <summary>
+            Gets the effective level for this logger.
+            </summary>
+            <returns>The nearest level in the logger hierarchy.</returns>
+            <remarks>
+            <para>
+            Starting from this logger, searches the logger hierarchy for a
+            non-null level and returns it. Otherwise, returns the level of the
+            root logger.
+            </para>
+            <para>The Logger class is designed so that this method executes as
+            quickly as possible.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>The hierarchy that this logger belongs to.</value>
+            <remarks>
+            <para>
+            This logger must be attached to a single <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.
+            </value>
+            <remarks>
+            <para>
+            The assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> can be <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Appenders">
+            <summary>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <returns>A collection of the appenders in this logger</returns>
+            <remarks>
+            <para>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>. If no appenders 
+            can be found, then a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Name">
+            <summary>
+            Gets the logger name.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl.#ctor(System.String)">
+            <summary>
+            Construct a new Logger
+            </summary>
+            <param name="name">the name of the logger</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl"/> class
+            with the specified name. 
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
+            <summary>
+            Delegate used to handle logger creation event notifications.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> in which the <see cref="T:log4net.Repository.Hierarchy.Logger"/> has been created.</param>
+            <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args that hold the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a
+            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
+            <summary>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument 
+            class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
+            <summary>
+            Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy">
+            <summary>
+            Hierarchical organization of loggers
+            </summary>
+            <remarks>
+            <para>
+            <i>The casual user should not have to deal with this class
+            directly.</i>
+            </para>
+            <para>
+            This class is specialized in retrieving loggers by name and
+            also maintaining the logger hierarchy. Implements the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            The structure of the logger hierarchy is maintained by the
+            <see cref="M:GetLogger(string)"/> method. The hierarchy is such that children
+            link to their parent but parents do not have any references to their
+            children. Moreover, loggers can be instantiated in any order, in
+            particular descendant before ancestor.
+            </para>
+            <para>
+            In case a descendant is created before a particular ancestor,
+            then it creates a provision node for the ancestor and adds itself
+            to the provision node. Other descendants of the same ancestor add
+            themselves to the previously created provision node.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositorySkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.ILoggerRepository">
+            <summary>
+            Interface implemented by logger repositories.
+            </summary>
+            <remarks>
+            <para>
+            This interface is implemented by logger repositories. e.g. 
+            <see cref="N:log4net.Repository.Hierarchy"/>.
+            </para>
+            <para>
+            This interface is used by the <see cref="T:log4net.LogManager"/>
+            to obtain <see cref="T:log4net.ILog"/> interfaces.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
+            <summary>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If the names logger exists it is returned, otherwise
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers as an Array.
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
+            <summary>
+            Returns a named logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Returns a named logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
+            <summary>Shutdown the repository</summary>
+            <remarks>
+            <para>
+            Shutting down a repository will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <see cref="M:Shutdown()"/> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.ConfigurationMessages">
+            <summary>
+            Collection of internal messages captured during the most 
+            recent configuration process.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            <para>
+            These properties can be specified on a repository specific basis.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes the repository with default (empty) properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct the repository using specific properties
+            </summary>
+            <param name="properties">the properties to set for this repository</param>
+            <remarks>
+            <para>
+            Initializes the repository with specified properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
+            <summary>
+            Test if logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the repository
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the repository as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Return a new logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
+            <summary>
+            Shutdown the repository
+            </summary>
+            <remarks>
+            <para>
+            Shutdown the repository. Can be overridden in a subclass.
+            This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>
+            listeners and all attached plugins of the shutdown event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.LoggerRepositorySkeleton.declaringType">
+            <summary>
+            The fully qualified type of the LoggerRepositorySkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Adds an object renderer for a specific class. 
+            </summary>
+            <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>
+            <param name="rendererInstance">The object renderer used to render the object.</param>
+            <remarks>
+            <para>
+            Adds an object renderer for a specific class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository is shutting down
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository is shutting down.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration reset
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has been reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration changed
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">
+            <summary>
+            Raise a configuration changed event on this repository
+            </summary>
+            <param name="e">EventArgs.Empty</param>
+            <remarks>
+            <para>
+            Applications that programmatically change the configuration of the repository should
+            raise this event notification to notify listeners.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes all configured Appenders that implement <see cref="T:log4net.Appender.IFlushable"/>.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed,
+            or <see cref="F:System.Threading.Timeout.Infinite"/> to wait indefinitely.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The string name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of this repository. The name is
+            used to store and lookup the repositories 
+            stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.ConfigurationMessages">
+            <summary>
+            Contains a list of internal messages captures during the 
+            last configuration.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            These properties can be specified on a repository specific basis
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
+            <summary>
+            Basic Configurator interface for repositories
+            </summary>
+            <remarks>
+            <para>
+            Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>
+            with a default <see cref="T:log4net.Appender.IAppender"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the repository using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the repository using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IXmlRepositoryConfigurator">
+            <summary>
+            Configure repository using XML
+            </summary>
+            <remarks>
+            <para>
+            Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the repository using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            The schema for the XML configuration data is defined by
+            the implementation.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct with properties
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with a logger factory
+            </summary>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with properties and a logger factory
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
+            <summary>
+            Test if a logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the hierarchy. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the hierarchy as an Array
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the hierarchy as an Array.
+            The root logger is <b>not</b> included in the returned
+            enumeration.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </summary>
+            <remarks>
+            <para>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
+            <summary>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </summary>
+            <remarks>
+            <para>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <c>Shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
+            <summary>
+            Reset all values contained in this hierarchy instance to their default.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this hierarchy instance to their
+            default.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this hierarchy.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">
+            <summary>
+            Returns all the Appenders that are currently configured
+            </summary>
+            <returns>An array containing all the currently configured appenders</returns>
+            <remarks>
+            <para>
+            Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.
+            All the loggers are searched for appenders. The appenders may also be containers
+            for appenders and these are also searched for additional loggers.
+            </para>
+            <para>
+            The list returned is unordered but does not contain duplicates.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.
+            The appender may also be a container.
+            </summary>
+            <param name="appenderList"></param>
+            <param name="appender"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container
+            </summary>
+            <param name="appenderList"></param>
+            <param name="container"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the log4net system using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">
+            <summary>
+            Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="level">The level to check against.</param>
+            <returns>
+            <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.
+            </returns>
+            <remarks>
+            <para>
+            If this hierarchy has not been configured then this method will
+            always return <c>true</c>.
+            </para>
+            <para>
+            This method will return <c>true</c> if this repository is
+            disabled for <c>level</c> object passed as parameter and
+            <c>false</c> otherwise.
+            </para>
+            <para>
+            See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
+            <summary>
+            Clear all logger definitions from the internal hashtable
+            </summary>
+            <remarks>
+            <para>
+            This call will clear all logger definitions from the internal
+            hashtable. Invoking this method will irrevocably mess up the
+            logger hierarchy.
+            </para>
+            <para>
+            You should <b>really</b> know what you are doing before
+            invoking this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            <paramref name="factory"/>.
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <param name="factory">The factory that will make the new logger instance</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated by the
+            <paramref name="factory"/> parameter and linked with its existing
+            ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Sends a logger creation event to all registered listeners
+            </summary>
+            <param name="logger">The newly created logger</param>
+            <remarks>
+            Raises the logger creation event.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Updates all the parents of the specified logger
+            </summary>
+            <param name="log">The logger to update the parents for</param>
+            <remarks>
+            <para>
+            This method loops through all the <i>potential</i> parents of
+            <paramref name="log"/>. There 3 possible cases:
+            </para>
+            <list type="number">
+            	<item>
+            		<term>No entry for the potential parent of <paramref name="log"/> exists</term>
+            		<description>
+            		We create a ProvisionNode for this potential 
+            		parent and insert <paramref name="log"/> in that provision node.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type Logger for the potential parent.</term>
+            		<description>
+            		The entry is <paramref name="log"/>'s nearest existing parent. We 
+            		update <paramref name="log"/>'s parent field with this entry. We also break from 
+            		he loop because updating our parent's parent is our parent's 
+            		responsibility.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type ProvisionNode for this potential parent.</term>
+            		<description>
+            		We add <paramref name="log"/> to the list of children for this 
+            		potential parent.
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
+            </summary>
+            <param name="pn"></param>
+            <param name="log"></param>
+            <remarks>
+            <para>
+            We update the links for all the children that placed themselves
+            in the provision node 'pn'. The second argument 'log' is a
+            reference for the newly created Logger, parent of all the
+            children in 'pn'.
+            </para>
+            <para>
+            We loop on all the children 'c' in 'pn'.
+            </para>
+            <para>
+            If the child 'c' has been already linked to a child of
+            'log' then there is no need to update 'c'.
+            </para>
+            <para>
+            Otherwise, we set log's parent field to c's parent and set
+            c's parent field to log.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">
+            <summary>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="levelEntry">the level values</param>
+            <remarks>
+            <para>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </para>
+            <para>
+            Supports setting levels via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="propertyEntry">the property value</param>
+            <remarks>
+            <para>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.
+            </para>
+            <para>
+            Supports setting property values via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Hierarchy.declaringType">
+            <summary>
+            The fully qualified type of the Hierarchy class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">
+            <summary>
+            Event used to notify that a logger has been created.
+            </summary>
+            <remarks>
+            <para>
+            Event raised when a logger is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
+            <summary>
+            Has no appender warning been emitted
+            </summary>
+            <remarks>
+            <para>
+            Flag to indicate if we have already issued a warning
+            about not having an appender warning.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
+            <summary>
+            Get the root of this hierarchy
+            </summary>
+            <remarks>
+            <para>
+            Get the root of this hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
+            <summary>
+            Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.
+            </summary>
+            <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>
+            <remarks>
+            <para>
+            The logger factory is used to create logger instances.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">
+            <summary>
+            A class to hold the value, name and display name for a level
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the value, name and display name for a level
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">
+            <summary>
+            Value of the level
+            </summary>
+            <remarks>
+            <para>
+            If the value is not set (defaults to -1) the value will be looked
+            up for the current level with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">
+            <summary>
+            Name of the level
+            </summary>
+            <value>
+            The name of the level
+            </value>
+            <remarks>
+            <para>
+            The name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">
+            <summary>
+            Display name for the level
+            </summary>
+            <value>
+            The display name of the level
+            </value>
+            <remarks>
+            <para>
+            The display name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerKey">
+            <summary>
+            Used internally to accelerate hash table searches.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to improve performance of 
+            string keyed hashtables.
+            </para>
+            <para>
+            The hashcode of the string is cached for reuse.
+            The string is stored as an interned value.
+            When comparing two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> objects for equality 
+            the reference equality of the interned strings is compared.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.#ctor(System.String)">
+            <summary>
+            Construct key with string name
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> class 
+            with the specified name.
+            </para>
+            <para>
+            Stores the hashcode of the string and interns
+            the string key to optimize comparisons.
+            </para>
+            <note>
+            The Compact Framework 1.0 the <see cref="M:System.String.Intern(System.String)"/>
+            method does not work. On the Compact Framework
+            the string keys are not interned nor are they
+            compared by reference.
+            </note>
+            </remarks>
+            <param name="name">The name of the logger.</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.GetHashCode">
+            <summary>
+            Returns a hash code for the current instance.
+            </summary>
+            <returns>A hash code for the current instance.</returns>
+            <remarks>
+            <para>
+            Returns the cached hashcode.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.Equals(System.Object)">
+            <summary>
+            Determines whether two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> instances 
+            are equal.
+            </summary>
+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>.</param>
+            <returns>
+            <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>.
+            </returns>
+            <remarks>
+            <para>
+            Compares the references of the interned strings.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">
+            <summary>
+            Provision nodes are used where no logger instance has been specified
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> instances are used in the 
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> when there is no specified 
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> for that node.
+            </para>
+            <para>
+            A provision node holds a list of child loggers on behalf of
+            a logger that does not exist.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Create a new provision node with child node
+            </summary>
+            <param name="log">A child logger to add to this node.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> class 
+            with the specified child logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.RootLogger">
+            <summary>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> sits at the root of the logger hierarchy tree. 
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> is a regular <see cref="T:log4net.Repository.Hierarchy.Logger"/> except 
+            that it provides several guarantees.
+            </para>
+            <para>
+            First, it cannot be assigned a <c>null</c>
+            level. Second, since the root logger cannot have a parent, the
+            <see cref="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel"/> property always returns the value of the
+            level field without walking the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.Core.Level)">
+            <summary>
+            Construct a <see cref="T:log4net.Repository.Hierarchy.RootLogger"/>
+            </summary>
+            <param name="level">The level to assign to the root logger.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> class with
+            the specified logging level.
+            </para>
+            <para>
+            The root logger names itself as "root". However, the root
+            logger cannot be retrieved by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.RootLogger.declaringType">
+            <summary>
+            The fully qualified type of the RootLogger class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel">
+            <summary>
+            Gets the assigned level value without walking the logger hierarchy.
+            </summary>
+            <value>The assigned level value without walking the logger hierarchy.</value>
+            <remarks>
+            <para>
+            Because the root logger cannot have a parent and its level
+            must not be <c>null</c> this property just returns the
+            value of <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> for the root logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> of the root logger.
+            </value>
+            <remarks>
+            <para>
+            Setting the level of the root logger to a <c>null</c> reference
+            may have catastrophic results. We prevent this here.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator">
+            <summary>
+            Initializes the log4net environment using an XML DOM.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.#ctor(log4net.Repository.Hierarchy.Hierarchy)">
+            <summary>
+            Construct the configurator for a hierarchy
+            </summary>
+            <param name="hierarchy">The hierarchy to build.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator"/> class
+            with the specified <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </summary>
+            <param name="element">The root element to parse.</param>
+            <remarks>
+            <para>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">
+            <summary>
+            Parse appenders by IDREF.
+            </summary>
+            <param name="appenderRef">The appender ref element.</param>
+            <returns>The instance of the appender that the ref refers to.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return 
+            the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">
+            <summary>
+            Parses an appender element.
+            </summary>
+            <param name="appenderElement">The appender element.</param>
+            <returns>The appender instance or <c>null</c> when parsing failed.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return
+            the appender instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLogger(System.Xml.XmlElement)">
+            <summary>
+            Parses a logger element.
+            </summary>
+            <param name="loggerElement">The logger element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRoot(System.Xml.XmlElement)">
+            <summary>
+            Parses the root logger element.
+            </summary>
+            <param name="rootElement">The root element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses the children of a logger element.
+            </summary>
+            <param name="catElement">The category element.</param>
+            <param name="log">The logger instance.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse the child elements of a &lt;logger&gt; element.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement)">
+            <summary>
+            Parses an object renderer.
+            </summary>
+            <param name="element">The renderer element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a renderer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses a level element.
+            </summary>
+            <param name="element">The level element.</param>
+            <param name="log">The logger object to set the level on.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">
+            <summary>
+            Sets a parameter on an object.
+            </summary>
+            <param name="element">The parameter element.</param>
+            <param name="target">The object to set the parameter on.</param>
+            <remarks>
+            The parameter name must correspond to a writable property
+            on the object. The value of the parameter is a string,
+            therefore this function will attempt to set a string
+            property first. If unable to set a string property it
+            will inspect the property and its argument type. It will
+            attempt to call a static method called <c>Parse</c> on the
+            type of the property. This method will take a single
+            string argument and return a value that can be used to
+            set the property.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.HasAttributesOrElements(System.Xml.XmlElement)">
+            <summary>
+            Test if an element has no attributes or child elements
+            </summary>
+            <param name="element">the element to inspect</param>
+            <returns><c>true</c> if the element has any attributes or child elements, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.IsTypeConstructible(System.Type)">
+            <summary>
+            Test if a <see cref="T:System.Type"/> is constructible with <c>Activator.CreateInstance</c>.
+            </summary>
+            <param name="type">the type to inspect</param>
+            <returns><c>true</c> if the type is creatable using a default constructor, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindMethodInfo(System.Type,System.String)">
+            <summary>
+            Look for a method on the <paramref name="targetType"/> that matches the <paramref name="name"/> supplied
+            </summary>
+            <param name="targetType">the type that has the method</param>
+            <param name="name">the name of the method</param>
+            <returns>the method info found</returns>
+            <remarks>
+            <para>
+            The method must be a public instance method on the <paramref name="targetType"/>.
+            The method must be named <paramref name="name"/> or "Add" followed by <paramref name="name"/>.
+            The method must take a single parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string value to a target type.
+            </summary>
+            <param name="type">The type of object to convert the string to.</param>
+            <param name="value">The string value to use as the value of the object.</param>
+            <returns>
+            <para>
+            An object of type <paramref name="type"/> with value <paramref name="value"/> or 
+            <c>null</c> when the conversion could not be performed.
+            </para>
+            </returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement,System.Type,System.Type)">
+            <summary>
+            Creates an object as specified in XML.
+            </summary>
+            <param name="element">The XML element that contains the definition of the object.</param>
+            <param name="defaultTargetType">The object type to use if not explicitly specified.</param>
+            <param name="typeConstraint">The type that the returned object must be or must inherit from.</param>
+            <returns>The object or <c>null</c></returns>
+            <remarks>
+            <para>
+            Parse an XML element and create an object instance based on the configuration
+            data.
+            </para>
+            <para>
+            The type of the instance may be specified in the XML. If not
+            specified then the <paramref name="defaultTargetType"/> is used
+            as the type. However the type is specified it must support the
+            <paramref name="typeConstraint"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_appenderBag">
+            <summary>
+            key: appenderName, value: appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_hierarchy">
+            <summary>
+            The Hierarchy being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlHierarchyConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.ConfigurationChangedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.ConfigurationChangedEventArgs.#ctor(System.Collections.ICollection)">
+            <summary>
+            
+            </summary>
+            <param name="configurationMessages"></param>
+        </member>
+        <member name="P:log4net.Repository.ConfigurationChangedEventArgs.ConfigurationMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryShutdownEventHandler">
+            <summary>
+            Delegate used to handle logger repository shutdown event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository shutdown event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationResetEventHandler">
+            <summary>
+            Delegate used to handle logger repository configuration reset event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration reset.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository configuration reset event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationChangedEventHandler">
+            <summary>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration changed.</param>
+            <param name="e">Empty event arguments.</param>
+            <remarks>
+            <para>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppDomainPatternConverter">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the name of the current AppDomain to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppDomainPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes name of the current AppDomain to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppSettingPatternConverter">
+            <summary>
+            AppSetting pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads appSettings from the application configuration file.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single appSettings value. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all appSettings will be dumped as a list of key value pairs.
+            </para>
+            <para>
+            A typical use is to specify a base directory for log files, e.g.
+            <example>
+            <![CDATA[
+            <log4net>
+               <appender name="MyAppender" type="log4net.Appender.RollingFileAppender">
+                 <file type="log4net.Util.PatternString" value="appsetting{LogDirectory}MyApp.log"/>
+                  ...
+              </appender>
+            </log4net>
+            ]]>
+            </example>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppSettingPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.DatePatternConverter">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The date and time is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date and time passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter">
+            <summary>
+            Write an <see cref="T:System.Environment.SpecialFolder"/> folder path to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an special path environment folder path to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output. <see cref="P:log4net.Util.PatternConverter.Option"/>
+            should be a value in the <see cref="T:System.Environment.SpecialFolder"/> enumeration.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an special path environment folder path to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the special path environment folder path to the output <paramref name="writer"/>.
+            The name of the special path environment folder path to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentFolderPathPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentPatternConverter">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an environment variable to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the environment variable to the output <paramref name="writer"/>.
+            The name of the environment variable to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.IdentityPatternConverter">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current thread identity to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.IdentityPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the current thread identity to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.IdentityPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the IdentityPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">
+            <summary>
+            Pattern converter for literal string instances in the pattern
+            </summary>
+            <remarks>
+            <para>
+            Writes the literal string value specified in the 
+            <see cref="P:log4net.Util.PatternConverter.Option"/> property to 
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next converter in the chain
+            </summary>
+            <param name="pc">The next pattern converter in the chain</param>
+            <returns>The next pattern converter</returns>
+            <remarks>
+            <para>
+            Special case the building of the pattern converter chain
+            for <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> instances. Two adjacent
+            literals in the pattern can be represented by a single combined
+            pattern converter. This implementation detects when a 
+            <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> is added to the chain
+            after this converter and combines its value with this converter's
+            literal value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the literal to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            Override the formatting behavior to ignore the FormattingInfo
+            because we have a literal instead.
+            </para>
+            <para>
+            Writes the value of <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Convert this pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            This method is not used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.NewLinePatternConverter">
+            <summary>
+            Writes a newline to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the system dependent line terminator to the output.
+            This behavior can be overridden by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>:
+            </para>
+            <list type="definition">
+              <listheader>
+                <term>Option Value</term>
+                <description>Output</description>
+              </listheader>
+              <item>
+                <term>DOS</term>
+                <description>DOS or Windows line terminator <c>"\r\n"</c></description>
+              </item>
+              <item>
+                <term>UNIX</term>
+                <description>UNIX line terminator <c>"\n"</c></description>
+              </item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.ProcessIdPatternConverter">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current process ID to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current process ID to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the ProcessIdPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads the thread and global properties.
+            The thread properties take priority over global properties.
+            See <see cref="P:log4net.ThreadContext.Properties"/> for details of the 
+            thread properties. See <see cref="P:log4net.GlobalContext.Properties"/> for
+            details of the global properties.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single property. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all properties will be dumped as a list of key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.PropertyPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.RandomStringPatternConverter">
+            <summary>
+            A Pattern converter that generates a string of random characters
+            </summary>
+            <remarks>
+            <para>
+            The converter generates a string of random characters. By default
+            the string is length 4. This can be changed by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the string value of the length required.
+            </para>
+            <para>
+            The random characters in the string are limited to uppercase letters
+            and numbers only.
+            </para>
+            <para>
+            The random number generator used by this class is not cryptographically secure.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.s_random">
+            <summary>
+            Shared random number generator
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.m_length">
+            <summary>
+            Length of random string to generate. Default length 4.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write a randoim string to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write a randoim string to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the RandomStringPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UserNamePatternConverter">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current threads username to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UserNamePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current threads username to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UserNamePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UserNamePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter">
+            <summary>
+            Write the UTC date time to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UtcDatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date and time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date is in Universal time when it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.BooleanConverter">
+            <summary>
+            Type converter for Boolean.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <c>bool</c> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            <summary>
+            Exception base type for conversion errors.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConverterRegistry">
+            <summary>
+            Register of type converters for specific types.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a registry of type converters used to convert between
+            types.
+            </para>
+            <para>
+            Use the <see cref="M:AddConverter(Type, object)"/> and 
+            <see cref="M:AddConverter(Type, Type)"/> methods to register new converters.
+            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
+            lookup appropriate converters to use.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConverterRegistry"/> class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#cctor">
+            <summary>
+            Static constructor.
+            </summary>
+            <remarks>
+            <para>
+            This constructor defines the intrinsic type converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Object)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converter">The type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter instance for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Type)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converterType">The type of the type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter <see cref="T:System.Type"/> for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="sourceType">The type being converted from.</param>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConverterFromAttribute(System.Type)">
+            <summary>
+            Lookups the type converter to use as specified by the attributes on the 
+            destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.CreateConverterInstance(System.Type)">
+            <summary>
+            Creates the instance of the type converter.
+            </summary>
+            <param name="converterType">The type of the type converter.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            The type specified for the type converter must implement 
+            the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> or <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces 
+            and must have a public default (no argument) constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.declaringType">
+            <summary>
+            The fully qualified type of the ConverterRegistry class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.s_type2converter">
+            <summary>
+            Mapping from <see cref="T:System.Type"/> to type converter.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.EncodingConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an encoding</param>
+            <returns>the encoding</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to 
+            convert the <see cref="T:System.String"/> argument to an <see cref="T:System.Text.Encoding"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertTo">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from a single type to arbitrary types.
+            See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.CanConvertTo(System.Type)">
+            <summary>
+            Returns whether this converter can convert the object to the specified type
+            </summary>
+            <param name="targetType">A Type that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the type supported by this converter can be converted to the
+            <paramref name="targetType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> (which must be of the type supported
+            by this converter) to the <paramref name="targetType"/> specified..
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IPAddressConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an IPAddress</param>
+            <returns>the IPAddress</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Net.IPAddress.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to an <see cref="T:System.Net.IPAddress"/>.
+            If that fails then the string is resolved as a DNS hostname.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.IPAddressConverter.validIpAddressChars">
+            <summary>
+            Valid characters in an IPv4 or IPv6 address string. (Does not support subnets)
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternLayoutConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> 
+            of the <see cref="T:log4net.Layout.PatternLayout"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternLayout</param>
+            <returns>the PatternLayout</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Layout.PatternLayout"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternStringConverter">
+            <summary>
+            Convert between string and <see cref="T:log4net.Util.PatternString"/>
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Util.PatternString"/> type, 
+            and from a <see cref="T:log4net.Util.PatternString"/> type to a string.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Util.PatternString.ConversionPattern"/> 
+            of the <see cref="T:log4net.Util.PatternString"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)">
+            <summary>
+            Can the target type be converted to the type supported by this object
+            </summary>
+            <param name="targetType">A <see cref="T:System.Type"/> that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="targetType"/> is
+            assignable from a <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:PatternString.Format()"/> method to convert the
+            <see cref="T:log4net.Util.PatternString"/> argument to a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            <paramref name="targetType"/>. To check for this condition use the 
+            <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)"/> method.
+            </exception>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternString</param>
+            <returns>the PatternString</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Util.PatternString"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Util.PatternString.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a Type</param>
+            <returns>the Type</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Type"/>.
+            Additional effort is made to locate partially specified types
+            by searching the loaded assemblies.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">
+            <summary>
+            Attribute used to associate a type converter
+            </summary>
+            <remarks>
+            <para>
+            Class and Interface level attribute that specifies a type converter
+            to use with the associated type.
+            </para>
+            <para>
+            To associate a type converter with a target type apply a
+            <c>TypeConverterAttribute</c> to the target type. Specify the
+            type of the type converter on the attribute.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">
+            <summary>
+            The string type name of the type converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">
+            <summary>
+            Create a new type converter attribute for the specified type name
+            </summary>
+            <param name="typeName">The string type name of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">
+            <summary>
+            Create a new type converter attribute for the specified type
+            </summary>
+            <param name="converterType">The type of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">
+            <summary>
+            The string type name of the type converter 
+            </summary>
+            <value>
+            The string type name of the type converter 
+            </value>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.AppenderAttachedImpl">
+            <summary>
+            A straightforward implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This is the default implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/>
+            interface. Implementors of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            should aggregate an instance of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.AppenderAttachedImpl"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvents">The array of events being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.CallAppend(log4net.Appender.IAppender,log4net.Core.LoggingEvent[])">
+            <summary>
+            Calls the DoAppende method on the <see cref="T:log4net.Appender.IAppender"/> with 
+            the <see cref="T:log4net.Core.LoggingEvent"/> objects supplied.
+            </summary>
+            <param name="appender">The appender</param>
+            <param name="loggingEvents">The events</param>
+            <remarks>
+            <para>
+            If the <paramref name="appender"/> supports the <see cref="T:log4net.Appender.IBulkAppender"/>
+            interface then the <paramref name="loggingEvents"/> will be passed 
+            through using that interface. Otherwise the <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the array will be passed one at a time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="newAppender">The appender to add.</param>
+            <remarks>
+            <para>
+            If the appender is already in the list it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup an attached appender by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderList">
+            <summary>
+            List of appenders
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderArray">
+            <summary>
+            Array of appenders, used to cache the m_appenderList
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.declaringType">
+            <summary>
+            The fully qualified type of the AppenderAttachedImpl class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.AppenderAttachedImpl.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <returns>
+            A collection of attached appenders, or <c>null</c> if there
+            are no attached appenders.
+            </returns>
+            <remarks>
+            <para>
+            The read only collection of all currently attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CompositeProperties">
+            <summary>
+            This class aggregates several PropertiesDictionary collections together.
+            </summary>
+            <remarks>
+            <para>
+            Provides a dictionary style lookup over an ordered list of
+            <see cref="T:log4net.Util.PropertiesDictionary"/> collections.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CompositeProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Add(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Add a Properties Dictionary to this composite collection
+            </summary>
+            <param name="properties">the properties to add</param>
+            <remarks>
+            <para>
+            Properties dictionaries added first take precedence over dictionaries added
+            later.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Flatten">
+            <summary>
+            Flatten this composite collection into a single properties dictionary
+            </summary>
+            <returns>the flattened dictionary</returns>
+            <remarks>
+            <para>
+            Reduces the collection of ordered dictionaries to a single dictionary
+            containing the resultant values for the keys.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CompositeProperties.Item(System.String)">
+            <summary>
+            Gets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Looks up the value for the <paramref name="key"/> specified.
+            The <see cref="T:log4net.Util.PropertiesDictionary"/> collections are searched
+            in the order in which they were added to this collection. The value
+            returned is the value held by the first collection that contains
+            the specified key.
+            </para>
+            <para>
+            If none of the collections contain the specified key then
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ContextPropertiesBase">
+            <summary>
+            Base class for Context Properties implementations
+            </summary>
+            <remarks>
+            <para>
+            This class defines a basic property get set accessor
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ConverterInfo">
+            <summary>
+            Wrapper class used to map converter names to converter types
+            </summary>
+            <remarks>
+            <para>
+            Pattern converter info class used during configuration by custom
+            PatternString and PatternLayer converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.#ctor">
+            <summary>
+            default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            
+            </summary>
+            <param name="entry"></param>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Name">
+            <summary>
+            Gets or sets the name of the conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            The name of the pattern in the format string
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Type">
+            <summary>
+            Gets or sets the type of the converter
+            </summary>
+            <remarks>
+            <para>
+            The value specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.CountingQuietTextWriter">
+            <summary>
+            Subclass of <see cref="T:log4net.Util.QuietTextWriter"/> that maintains a count of 
+            the number of bytes written.
+            </summary>
+            <remarks>
+            <para>
+            This writer counts the number of bytes written.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.QuietTextWriter">
+            <summary>
+            <see cref="T:System.IO.TextWriter"/> that does not leak exceptions
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Util.QuietTextWriter"/> does not throw exceptions when things go wrong. 
+            Instead, it delegates error handling to its <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TextWriterAdapter">
+            <summary>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.TextWriterAdapter.m_writer">
+            <summary>
+            The writer to forward messages to
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Close">
+            <summary>
+            Closes the writer and releases any system resources associated with the writer
+            </summary>
+            <remarks>
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">
+            <summary>
+            Dispose this writer
+            </summary>
+            <param name="disposing">flag indicating if we are being disposed</param>
+            <remarks>
+            <para>
+            Dispose this writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Flush">
+            <summary>
+            Flushes any buffered output
+            </summary>
+            <remarks>
+            <para>
+            Clears all buffers for the writer and causes any buffered data to be written 
+            to the underlying device
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">
+            <summary>
+            Writes a character to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a character to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a character buffer to the wrapped TextWriter
+            </summary>
+            <param name="buffer">the data buffer</param>
+            <param name="index">the start index</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a character buffer to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">
+            <summary>
+            Writes a string to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a string to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Writer">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.IO.TextWriter"/>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Encoding">
+            <summary>
+            The Encoding in which the output is written
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>
+            </value>
+            <remarks>
+            <para>
+            The Encoding in which the output is written
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">
+            <summary>
+            Gets an object that controls formatting
+            </summary>
+            <value>
+            The format provider
+            </value>
+            <remarks>
+            <para>
+            Gets an object that controls formatting
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.NewLine">
+            <summary>
+            Gets or sets the line terminator string used by the TextWriter
+            </summary>
+            <value>
+            The line terminator to use
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the line terminator string used by the TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <param name="errorHandler">the error handler to report error to</param>
+            <remarks>
+            <para>
+            Create a new QuietTextWriter using a writer and error handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Writes a character to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a buffer to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output.
+            </summary>
+            <param name="value">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Writes a string to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Close">
+            <summary>
+            Closes the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_errorHandler">
+            <summary>
+            The error handler instance to pass all errors to
+            </summary>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_closed">
+            <summary>
+            Flag to indicate if this writer is closed
+            </summary>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.ErrorHandler">
+            <summary>
+            Gets or sets the error handler that all errors are passed to.
+            </summary>
+            <value>
+            The error handler that all errors are passed to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the error handler that all errors are passed to.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.Closed">
+            <summary>
+            Gets a value indicating whether this writer is closed.
+            </summary>
+            <value>
+            <c>true</c> if this writer is closed, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets a value indicating whether this writer is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to actually write to.</param>
+            <param name="errorHandler">The <see cref="T:log4net.Core.IErrorHandler"/> to report errors to.</param>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.CountingQuietTextWriter"/> class 
+            with the specified <see cref="T:System.IO.TextWriter"/> and <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output and counts the number of bytes written.
+            </summary>
+            <param name="str">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.CountingQuietTextWriter.m_countBytes">
+            <summary>
+            Total number of bytes written.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.CountingQuietTextWriter.Count">
+            <summary>
+            Gets or sets the total number of bytes written.
+            </summary>
+            <value>
+            The total number of bytes written.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the total number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CyclicBuffer">
+            <summary>
+            A fixed size rolling buffer of logging events.
+            </summary>
+            <remarks>
+            <para>
+            An array backed fixed size leaky bucket.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="maxSize">The maximum number of logging events in the buffer.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with 
+            the specified maximum number of buffered logging events.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Appends a <paramref name="loggingEvent"/> to the buffer.
+            </summary>
+            <param name="loggingEvent">The event to append to the buffer.</param>
+            <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Append an event to the buffer. If the buffer still contains free space then
+            <c>null</c> is returned. If the buffer is full then an event will be dropped
+            to make space for the new event, the event dropped is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopOldest">
+            <summary>
+            Get and remove the oldest event in the buffer.
+            </summary>
+            <returns>The oldest logging event in the buffer</returns>
+            <remarks>
+            <para>
+            Gets the oldest (first) logging event in the buffer and removes it 
+            from the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopAll">
+            <summary>
+            Pops all the logging events from the buffer into an array.
+            </summary>
+            <returns>An array of all the logging events in the buffer.</returns>
+            <remarks>
+            <para>
+            Get all the events in the buffer and clear the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Clear">
+            <summary>
+            Clear the buffer
+            </summary>
+            <remarks>
+            <para>
+            Clear the buffer of all events. The events in the buffer are lost.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">
+            <summary>
+            Gets the <paramref name="i"/>th oldest event currently in the buffer.
+            </summary>
+            <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>
+            <remarks>
+            <para>
+            If <paramref name="i"/> is outside the range 0 to the number of events
+            currently in the buffer, then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.MaxSize">
+            <summary>
+            Gets the maximum size of the buffer.
+            </summary>
+            <value>The maximum size of the buffer.</value>
+            <remarks>
+            <para>
+            Gets the maximum size of the buffer
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Length">
+            <summary>
+            Gets the number of logging events in the buffer.
+            </summary>
+            <value>The number of logging events in the buffer.</value>
+            <remarks>
+            <para>
+            This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>
+            (inclusive).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyCollection">
+            <summary>
+            An always empty <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.ICollection"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyCollection"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.EmptyCollection.s_instance">
+            <summary>
+            The singleton instance of the empty collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Instance">
+            <summary>
+            Gets the singleton instance of the empty collection.
+            </summary>
+            <returns>The singleton instance of the empty collection.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the empty collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyCollection.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyCollection.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyDictionary">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionary"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyDictionary"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Add(System.Object,System.Object)">
+            <summary>
+            Adds an element with the provided key and value to the 
+            <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>
+            <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>
+            <remarks>
+            <para>
+            As the collection is empty no new values can be added. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Clear">
+            <summary>
+            Removes all elements from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Contains(System.Object)">
+            <summary>
+            Determines whether the <see cref="T:log4net.Util.EmptyDictionary"/> contains an element 
+            with the specified key.
+            </summary>
+            <param name="key">The key to locate in the <see cref="T:log4net.Util.EmptyDictionary"/>.</param>
+            <returns><c>false</c></returns>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="M:log4net.Util.EmptyDictionary.Contains(System.Object)"/> method always returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Remove(System.Object)">
+            <summary>
+            Removes the element with the specified key from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The key of the element to remove.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="F:log4net.Util.EmptyDictionary.s_instance">
+            <summary>
+            The singleton instance of the empty dictionary.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <b>true</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyDictionary.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyDictionary.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> has a fixed size.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsFixedSize"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> is read-only.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsReadOnly"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Keys">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Values">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Item(System.Object)">
+            <summary>
+            Gets or sets the element with the specified key.
+            </summary>
+            <param name="key">The key of the element to get or set.</param>
+            <value><c>null</c></value>
+            <remarks>
+            <para>
+            As the collection is empty no values can be looked up or stored. 
+            If the index getter is called then <c>null</c> is returned.
+            A <see cref="T:System.InvalidOperationException"/> is thrown if the setter is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="T:log4net.Util.FormattingInfo">
+            <summary>
+            Contain the information obtained when parsing formatting modifiers 
+            in conversion modifiers.
+            </summary>
+            <remarks>
+            <para>
+            Holds the formatting information extracted from the format string by
+            the <see cref="T:log4net.Util.PatternParser"/>. This is used by the <see cref="T:log4net.Util.PatternConverter"/>
+            objects when rendering the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor">
+            <summary>
+            Defaut Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor(System.Int32,System.Int32,System.Boolean)">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class
+            with the specified parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Min">
+            <summary>
+            Gets or sets the minimum value.
+            </summary>
+            <value>
+            The minimum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the minimum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Max">
+            <summary>
+            Gets or sets the maximum value.
+            </summary>
+            <value>
+            The maximum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the maximum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.LeftAlign">
+            <summary>
+            Gets or sets a flag indicating whether left align is enabled
+            or not.
+            </summary>
+            <value>
+            A flag indicating whether left align is enabled or not.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a flag indicating whether left align is enabled or not.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.GlobalContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.GlobalContext"/>
+            </summary>
+            <remarks>
+            <para>
+            This class implements a properties collection that is thread safe and supports both
+            storing properties and capturing a read only copy of the current propertied.
+            </para>
+            <para>
+            This class is optimized to the scenario where the properties are read frequently
+            and are modified infrequently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_readOnlyProperties">
+            <summary>
+            The read only copy of the properties.
+            </summary>
+            <remarks>
+            <para>
+            This variable is declared <c>volatile</c> to prevent the compiler and JIT from
+            reordering reads and writes of this thread performed on different threads.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_syncRoot">
+            <summary>
+            Lock object used to synchronize updates within this instance
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.GlobalContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property from the global context
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Removing an entry from the global context properties is relatively expensive compared
+            with reading a value. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Clear">
+            <summary>
+            Clear the global context properties
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.GetReadOnlyProperties">
+            <summary>
+            Get a readonly immutable copy of the properties
+            </summary>
+            <returns>the current global context properties</returns>
+            <remarks>
+            <para>
+            This implementation is fast because the GlobalContextProperties class
+            stores a readonly copy of the properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.GlobalContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Reading the value for a key is faster than setting the value.
+            When the value is written a new read only copy of 
+            the properties is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ILogExtensions">
+            <summary>
+            The static class ILogExtensions contains a set of widely used
+            methods that ease the interaction with the ILog interface implementations.
+            </summary>
+            <remarks>
+            <para>
+            This class contains methods for logging at different levels and checks the
+            properties for determining if those logging levels are enabled in the current
+            configuration.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            using log4net.Util;
+            
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.InfoExt("Application Start");
+            log.DebugExt("This is a debug message");
+            </code>
+            </example>
+        </member>
+        <member name="F:log4net.Util.ILogExtensions.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="T:log4net.Util.LevelMapping">
+            <summary>
+            Manages a mapping from levels to <see cref="T:log4net.Util.LevelMappingEntry"/>
+            </summary>
+            <remarks>
+            <para>
+            Manages an ordered mapping from <see cref="T:log4net.Core.Level"/> instances 
+            to <see cref="T:log4net.Util.LevelMappingEntry"/> subclasses.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialise a new instance of <see cref="T:log4net.Util.LevelMapping"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Add(log4net.Util.LevelMappingEntry)">
+            <summary>
+            Add a <see cref="T:log4net.Util.LevelMappingEntry"/> to this mapping
+            </summary>
+            <param name="entry">the entry to add</param>
+            <remarks>
+            <para>
+            If a <see cref="T:log4net.Util.LevelMappingEntry"/> has previously been added
+            for the same <see cref="T:log4net.Core.Level"/> then that entry will be 
+            overwritten.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Lookup(log4net.Core.Level)">
+            <summary>
+            Lookup the mapping for the specified level
+            </summary>
+            <param name="level">the level to lookup</param>
+            <returns>the <see cref="T:log4net.Util.LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
+            <remarks>
+            <para>
+            Lookup the value for the specified level. Finds the nearest
+            mapping value for the level that is equal to or less than the
+            <paramref name="level"/> specified.
+            </para>
+            <para>
+            If no mapping could be found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.ActivateOptions">
+            <summary>
+            Initialize options
+            </summary>
+            <remarks>
+            <para>
+            Caches the sorted list of <see cref="T:log4net.Util.LevelMappingEntry"/> in an array
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            <para>
+            This class stores its properties in a slot on the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> named
+            <c>log4net.Util.LogicalThreadContextProperties</c>.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.m_disabled">
+            <summary>
+            Flag used to disable this context if we don't have permission to access the CallContext.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the value for the specified <paramref name="key"/> from the context.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Clear">
+            <summary>
+            Clear all the context properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all the context properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the PropertiesDictionary stored in the LocalDataStoreSlot for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doings so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetLogicalProperties">
+            <summary>
+            Gets the call context get data.
+            </summary>
+            <returns>The peroperties dictionary stored in the call context</returns>
+            <remarks>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.GetData(System.String)"/> has a
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.SetLogicalProperties(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Sets the call context data.
+            </summary>
+            <param name="properties">The properties.</param>
+            <remarks>
+            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
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.declaringType">
+            <summary>
+            The fully qualified type of the LogicalThreadContextProperties class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Get or set the property value for the <paramref name="key"/> specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TwoArgAction`2">
+            <summary>
+            Delegate type used for LogicalThreadContextStack's callbacks.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_propertyKey">
+            <summary>
+            The name of this <see cref="T:log4net.Util.LogicalThreadContextStack"/> within the
+            <see cref="T:log4net.Util.LogicalThreadContextProperties"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_registerNew">
+            <summary>
+            The callback used to let the <see cref="T:log4net.Util.LogicalThreadContextStacks"/> register a
+            new instance of a <see cref="T:log4net.Util.LogicalThreadContextStack"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.#ctor(System.String,log4net.Util.TwoArgAction{System.String,log4net.Util.LogicalThreadContextStack})">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this thread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.LogicalThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.LogicalThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_logicalThreadContextStack">
+            <summary>
+            The outer LogicalThreadContextStack.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.#ctor(log4net.Util.LogicalThreadContextStack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="logicalThreadContextStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStacks.#ctor(log4net.Util.LogicalThreadContextProperties)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventHandler">
+            <summary>
+            
+            </summary>
+            <param name="source"></param>
+            <param name="e"></param>
+        </member>
+        <member name="T:log4net.Util.LogLog">
+            <summary>
+            Outputs log statements from within the log4net assembly.
+            </summary>
+            <remarks>
+            <para>
+            Log4net components cannot make log4net logging calls. However, it is
+            sometimes useful for the user to learn about what log4net is
+            doing.
+            </para>
+            <para>
+            All log4net internal debug calls go to the standard output stream
+            whereas internal error messages are sent to the standard error output 
+            stream.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.LogLog.ToString">
+            <summary>
+            Formats Prefix, Source, and Message in the same format as the value
+            sent to Console.Out and Trace.Write.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.LogLog.#ctor(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogLog"/> class. 
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.#cctor">
+            <summary>
+            Static constructor that initializes logging by reading 
+            settings from the application configuration file.
+            </summary>
+            <remarks>
+            <para>
+            The <c>log4net.Internal.Debug</c> application setting
+            controls internal debugging. This setting should be set
+            to <c>true</c> to enable debugging.
+            </para>
+            <para>
+            The <c>log4net.Internal.Quiet</c> application setting
+            suppresses all internal logging including error messages. 
+            This setting should be set to <c>true</c> to enable message
+            suppression.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.OnLogReceived(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Raises the LogReceived event when an internal messages is received.
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source"></param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal error messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitOutLine(System.String)">
+            <summary>
+            Writes output to the standard output stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Out and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitErrorLine(System.String)">
+            <summary>
+            Writes output to the standard error stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Error and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_debugEnabled">
+            <summary>
+             Default debug level
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_quietMode">
+            <summary>
+            In quietMode not even errors generate any output.
+            </summary>
+        </member>
+        <member name="E:log4net.Util.LogLog.LogReceived">
+            <summary>
+            The event raised when an internal message has been received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Source">
+            <summary>
+            The Type that generated the internal message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStamp">
+            <summary>
+            The DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStampUtc">
+            <summary>
+            The UTC DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Prefix">
+            <summary>
+            A string indicating the severity of the internal message.
+            </summary>
+            <remarks>
+            "log4net: ", 
+            "log4net:ERROR ", 
+            "log4net:WARN "
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.Message">
+            <summary>
+            The internal log message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Exception">
+            <summary>
+            The Exception related to the message.
+            </summary>
+            <remarks>
+            Optional. Will be null if no Exception was passed.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.InternalDebugging">
+            <summary>
+            Gets or sets a value indicating whether log4net internal logging
+            is enabled or disabled.
+            </summary>
+            <value>
+            <c>true</c> if log4net internal logging is enabled, otherwise 
+            <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c>, internal debug level logging will be 
+            displayed.
+            </para>
+            <para>
+            This value can be set by setting the application setting 
+            <c>log4net.Internal.Debug</c> in the application configuration
+            file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. debugging is
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            The following example enables internal debugging using the 
+            application configuration file :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Debug" value="true" />
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.QuietMode">
+            <summary>
+            Gets or sets a value indicating whether log4net should generate no output
+            from internal logging, not even for errors. 
+            </summary>
+            <value>
+            <c>true</c> if log4net should generate no output at all from internal 
+            logging, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c> will cause internal logging at all levels to be 
+            suppressed. This means that no warning or error reports will be logged. 
+            This option overrides the <see cref="P:log4net.Util.LogLog.InternalDebugging"/> setting and 
+            disables all debug also.
+            </para>
+            <para>This value can be set by setting the application setting
+            <c>log4net.Internal.Quiet</c> in the application configuration file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. internal logging is not
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            The following example disables internal logging using the 
+            application configuration file :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Quiet" value="true"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.EmitInternalMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsDebugEnabled">
+            <summary>
+            Test if LogLog.Debug is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Debug is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Debug is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsWarnEnabled">
+            <summary>
+            Test if LogLog.Warn is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Warn is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Warn is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsErrorEnabled">
+            <summary>
+            Test if LogLog.Error is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Error is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Error is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogLog.LogReceivedAdapter">
+            <summary>
+            Subscribes to the LogLog.LogReceived event and stores messages
+            to the supplied IList instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.#ctor(System.Collections.IList)">
+            <summary>
+            
+            </summary>
+            <param name="items"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.Dispose">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.LogReceivedAdapter.Items">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogReceivedEventArgs.#ctor(log4net.Util.LogLog)">
+            <summary>
+            
+            </summary>
+            <param name="loglog"></param>
+        </member>
+        <member name="P:log4net.Util.LogReceivedEventArgs.LogLog">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.NativeError">
+            <summary>
+            Represents a native error code and message.
+            </summary>
+            <remarks>
+            <para>
+            Represents a Win32 platform native error.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NativeError.#ctor(System.Int32,System.String)">
+            <summary>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </summary>
+            <param name="number">The number of the native error.</param>
+            <param name="message">The message of the native error.</param>
+            <remarks>
+            <para>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetLastError">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class for the last Windows error.
+            </summary>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the last windows error.
+            </returns>
+            <remarks>
+            <para>
+            The message for the <see cref="M:System.Runtime.InteropServices.Marshal.GetLastWin32Error"/> error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetError(System.Int32)">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class.
+            </summary>
+            <param name="number">the error number for the native error</param>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the specified 
+            error number.
+            </returns>
+            <remarks>
+            <para>
+            The message for the specified error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetErrorMessage(System.Int32)">
+            <summary>
+            Retrieves the message corresponding with a Win32 message identifier.
+            </summary>
+            <param name="messageId">Message identifier for the requested message.</param>
+            <returns>
+            The message corresponding with the specified message identifier.
+            </returns>
+            <remarks>
+            <para>
+            The message will be searched for in system message-table resource(s)
+            using the native <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.ToString">
+            <summary>
+            Return error information string
+            </summary>
+            <returns>error information string</returns>
+            <remarks>
+            <para>
+            Return error information string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.FormatMessage(System.Int32,System.IntPtr@,System.Int32,System.Int32,System.String@,System.Int32,System.IntPtr)">
+            <summary>
+            Formats a message string.
+            </summary>
+            <param name="dwFlags">Formatting options, and how to interpret the <paramref name="lpSource" /> parameter.</param>
+            <param name="lpSource">Location of the message definition.</param>
+            <param name="dwMessageId">Message identifier for the requested message.</param>
+            <param name="dwLanguageId">Language identifier for the requested message.</param>
+            <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>
+            <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>
+            <param name="Arguments">Pointer to an array of values that are used as insert values in the formatted message.</param>
+            <remarks>
+            <para>
+            The function requires a message definition as input. The message definition can come from a 
+            buffer passed into the function. It can come from a message table resource in an 
+            already-loaded module. Or the caller can ask the function to search the system's message 
+            table resource(s) for the message definition. The function finds the message definition 
+            in a message table resource based on a message identifier and a language identifier. 
+            The function copies the formatted message text to an output buffer, processing any embedded 
+            insert sequences if requested.
+            </para>
+            <para>
+            To prevent the usage of unsafe code, this stub does not support inserting values in the formatted message.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is the number of TCHARs stored in the output 
+            buffer, excluding the terminating null character.
+            </para>
+            <para>
+            If the function fails, the return value is zero. To get extended error information, 
+            call <see cref="M:Marshal.GetLastWin32Error()" />.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Util.NativeError.Number">
+            <summary>
+            Gets the number of the native error.
+            </summary>
+            <value>
+            The number of the native error.
+            </value>
+            <remarks>
+            <para>
+            Gets the number of the native error.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NativeError.Message">
+            <summary>
+            Gets the message of the native error.
+            </summary>
+            <value>
+            The message of the native error.
+            </value>
+            <remarks>
+            <para>
+            </para>
+            Gets the message of the native error.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.NullDictionaryEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionaryEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionaryEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance.
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullDictionaryEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullDictionaryEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullDictionaryEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Key">
+            <summary>
+            Gets the current key from the enumerator.
+            </summary>
+            <remarks>
+            Throws an exception because the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>
+            never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Key"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Value">
+            <summary>
+            Gets the current value from the enumerator.
+            </summary>
+            <value>The current value from the enumerator.</value>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Value"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Entry">
+            <summary>
+            Gets the current entry from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current entry.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Entry"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Instance">
+            <summary>
+            Get the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullSecurityContext">
+            <summary>
+            A SecurityContext used when a SecurityContext is not required
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Util.NullSecurityContext"/> is a no-op implementation of the
+            <see cref="T:log4net.Core.SecurityContext"/> base class. It is used where a <see cref="T:log4net.Core.SecurityContext"/>
+            is required but one has not been provided.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.NullSecurityContext.Instance">
+            <summary>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            <para>
+            Private constructor for singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns><c>null</c></returns>
+            <remarks>
+            <para>
+            No impersonation is done and <c>null</c> is always returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OnlyOnceErrorHandler">
+            <summary>
+            Implements log4net's default error handling policy which consists 
+            of emitting a message for the first error in an appender and 
+            ignoring all subsequent errors.
+            </summary>
+            <remarks>
+            <para>
+            The error message is processed using the LogLog sub-system by default.
+            </para>
+            <para>
+            This policy aims at protecting an otherwise working application
+            from being flooded with error messages when logging fails.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="prefix">The prefix to use for each message.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class
+            with the specified prefix.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Reset">
+            <summary>
+            Reset the error handler back to its initial disabled state.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log the very first error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            Sends the error information to <see cref="T:log4net.Util.LogLog"/>'s Error method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">
+            <summary>
+            Log an error
+            </summary>
+            <param name="message">The error message.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_enabledDateUtc">
+            <summary>
+            The UTC date the error was recorded.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">
+            <summary>
+            Flag to indicate if it is the first error
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_message">
+            <summary>
+            The message recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_exception">
+            <summary>
+            The exception recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_errorCode">
+            <summary>
+            The error code recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">
+            <summary>
+            String to prefix each message with
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.declaringType">
+            <summary>
+            The fully qualified type of the OnlyOnceErrorHandler class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">
+            <summary>
+            Is error logging enabled
+            </summary>
+            <remarks>
+            <para>
+            Is error logging enabled. Logging is only enabled for the
+            first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDate">
+            <summary>
+            The date the first error that trigged this error handler occurred, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDateUtc">
+            <summary>
+            The UTC date the first error that trigged this error handler occured, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorMessage">
+            <summary>
+            The message from the first error that trigged this error handler.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.Exception">
+            <summary>
+            The exception from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            May be <see langword="null" />.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorCode">
+            <summary>
+            The error code from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            Defaults to <see cref="F:log4net.Core.ErrorCode.GenericFailure"/>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OptionConverter">
+            <summary>
+            A convenience class to convert property values to specific types.
+            </summary>
+            <remarks>
+            <para>
+            Utility functions for converting types and parsing values.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.OptionConverter"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToBoolean(System.String,System.Boolean)">
+            <summary>
+            Converts a string to a <see cref="T:System.Boolean"/> value.
+            </summary>
+            <param name="argValue">String to convert.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Boolean"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            If <paramref name="argValue"/> is "true", then <c>true</c> is returned. 
+            If <paramref name="argValue"/> is "false", then <c>false</c> is returned. 
+            Otherwise, <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToFileSize(System.String,System.Int64)">
+            <summary>
+            Parses a file size into a number.
+            </summary>
+            <param name="argValue">String to parse.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Int64"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            Parses a file size of the form: number[KB|MB|GB] into a
+            long value. It is scaled with the appropriate multiplier.
+            </para>
+            <para>
+            <paramref name="defaultValue"/> is returned when <paramref name="argValue"/>
+            cannot be converted to a <see cref="T:System.Int64"/> value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string to an object.
+            </summary>
+            <param name="target">The target type to convert to.</param>
+            <param name="txt">The string to convert to an object.</param>
+            <returns>
+            The object converted from a string or <c>null</c> when the 
+            conversion failed.
+            </returns>
+            <remarks>
+            <para>
+            Converts a string to an object. Uses the converter registry to try
+            to convert the string value into the specified target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.CanConvertTypeTo(System.Type,System.Type)">
+            <summary>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            </summary>
+            <param name="sourceType">The type to convert from.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns><c>true</c> if there is a conversion from the source type to the target type.</returns>
+            <remarks>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertTypeTo(System.Object,System.Type)">
+            <summary>
+            Converts an object to the target type.
+            </summary>
+            <param name="sourceInstance">The object to convert to the target type.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns>The converted object.</returns>
+            <remarks>
+            <para>
+            Converts an object to the target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">
+            <summary>
+            Instantiates an object given a class name.
+            </summary>
+            <param name="className">The fully qualified class name of the object to instantiate.</param>
+            <param name="superClass">The class to which the new object should belong.</param>
+            <param name="defaultValue">The object to return in case of non-fulfillment.</param>
+            <returns>
+            An instance of the <paramref name="className"/> or <paramref name="defaultValue"/>
+            if the object could not be instantiated.
+            </returns>
+            <remarks>
+            <para>
+            Checks that the <paramref name="className"/> is a subclass of
+            <paramref name="superClass"/>. If that test fails or the object could
+            not be instantiated, then <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.SubstituteVariables(System.String,System.Collections.IDictionary)">
+            <summary>
+            Performs variable substitution in string <paramref name="value"/> from the 
+            values of keys found in <paramref name="props"/>.
+            </summary>
+            <param name="value">The string on which variable substitution is performed.</param>
+            <param name="props">The dictionary to use to lookup variables.</param>
+            <returns>The result of the substitutions.</returns>
+            <remarks>
+            <para>
+            The variable substitution delimiters are <b>${</b> and <b>}</b>.
+            </para>
+            <para>
+            For example, if props contains <c>key=value</c>, then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of key is ${key}.");
+            </code>
+            </para>
+            <para>
+            will set the variable <c>s</c> to "Value of key is value.".
+            </para>
+            <para>
+            If no value could be found for the specified key, then substitution 
+            defaults to an empty string.
+            </para>
+            <para>
+            For example, if system properties contains no value for the key
+            "nonExistentKey", then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of nonExistentKey is [${nonExistentKey}]");
+            </code>
+            </para>
+            <para>
+            will set <s>s</s> to "Value of nonExistentKey is []".	 
+            </para>
+            <para>
+            An Exception is thrown if <paramref name="value"/> contains a start 
+            delimiter "${" which is not balanced by a stop delimiter "}". 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ParseEnum(System.Type,System.String,System.Boolean)">
+            <summary>
+            Converts the string representation of the name or numeric value of one or 
+            more enumerated constants to an equivalent enumerated object.
+            </summary>
+            <param name="enumType">The type to convert to.</param>
+            <param name="value">The enum string value.</param>
+            <param name="ignoreCase">If <c>true</c>, ignore case; otherwise, regard case.</param>
+            <returns>An object of type <paramref name="enumType" /> whose value is represented by <paramref name="value" />.</returns>
+        </member>
+        <member name="F:log4net.Util.OptionConverter.declaringType">
+            <summary>
+            The fully qualified type of the OptionConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser">
+            <summary>
+            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class
+            is delegated to the PatternParser class.
+            </summary>
+            <remarks>
+            <para>
+            The <c>PatternParser</c> processes a pattern string and
+            returns a chain of <see cref="T:log4net.Util.PatternConverter"/> objects.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.PatternParser.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="pattern">The pattern to parse.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternParser"/> class 
+            with the specified pattern string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.Parse">
+            <summary>
+            Parses the pattern into a chain of pattern converters.
+            </summary>
+            <returns>The head of a chain of pattern converters.</returns>
+            <remarks>
+            <para>
+            Parses the pattern into a chain of pattern converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.BuildCache">
+            <summary>
+            Build the unified cache of converters from the static and instance maps
+            </summary>
+            <returns>the list of all the converter names</returns>
+            <remarks>
+            <para>
+            Build the unified cache of converters from the static and instance maps
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ParseInternal(System.String,System.String[])">
+            <summary>
+            Internal method to parse the specified pattern to find specified matches
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <param name="matches">the converter names to match in the pattern</param>
+            <remarks>
+            <para>
+            The matches param must be sorted such that longer strings come before shorter ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessLiteral(System.String)">
+            <summary>
+            Process a parsed literal
+            </summary>
+            <param name="text">the literal text</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessConverter(System.String,System.String,log4net.Util.FormattingInfo)">
+            <summary>
+            Process a parsed converter pattern
+            </summary>
+            <param name="converterName">the name of the converter</param>
+            <param name="option">the optional option for the converter</param>
+            <param name="formattingInfo">the formatting info for the converter</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.AddConverter(log4net.Util.PatternConverter)">
+            <summary>
+            Resets the internal state of the parser and adds the specified pattern converter 
+            to the chain.
+            </summary>
+            <param name="pc">The pattern converter to add.</param>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_head">
+            <summary>
+            The first pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_tail">
+            <summary>
+             the last pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_pattern">
+            <summary>
+            The pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_patternConverters">
+            <summary>
+            Internal map of converter identifiers to converter types
+            </summary>
+            <remarks>
+            <para>
+            This map overrides the static s_globalRulesRegistry map.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternParser.declaringType">
+            <summary>
+            The fully qualified type of the PatternParser class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternParser.PatternConverters">
+            <summary>
+            Get the converter registry used by this parser
+            </summary>
+            <value>
+            The converter registry used by this parser
+            </value>
+            <remarks>
+            <para>
+            Get the converter registry used by this parser
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser.StringLengthComparer">
+            <summary>
+            Sort strings by length
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:System.Collections.IComparer"/> that orders strings by string length.
+            The longest strings are placed first
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternString">
+            <summary>
+            This class implements a patterned string.
+            </summary>
+            <remarks>
+            <para>
+            This string has embedded patterns that are resolved and expanded
+            when the string is formatted.
+            </para>
+            <para>
+            This class functions similarly to the <see cref="T:log4net.Layout.PatternLayout"/>
+            in that it accepts a pattern and renders it to a string. Unlike the 
+            <see cref="T:log4net.Layout.PatternLayout"/> however the <c>PatternString</c>
+            does not render the properties of a specific <see cref="T:log4net.Core.LoggingEvent"/> but
+            of the process in general.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+                        <para>
+                        Used to output the friendly name of the current AppDomain.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>appsetting</term>
+                    <description>
+                        <para>
+                        Used to output the value of a specific appSetting key in the application
+                        configuration file.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>date</term>
+                    <description>
+            			<para>
+            			Used to output the current date and time in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>env</term>
+                    <description>
+                        <para>
+            			Used to output the a specific environment variable. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%env{COMPUTERNAME}</b> would include the value
+            			of the <c>COMPUTERNAME</c> environment variable.
+                        </para>
+                        <para>
+                        The <c>env</c> pattern is not supported on the .NET Compact Framework.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>identity</term>
+                    <description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>newline</term>
+                    <description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern name offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+                    </description>
+                </item>
+                <item>
+                    <term>processid</term>
+                    <description>
+                        <para>
+            			Used to output the system process ID for the current process.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>property</term>
+                    <description>
+            			<para>
+            			Used to output a specific context property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are stored in logging contexts. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+                    </description>
+                </item>
+                <item>
+                    <term>random</term>
+                    <description>
+                        <para>
+                        Used to output a random string of characters. The string is made up of
+                        uppercase letters and numbers. By default the string is 4 characters long.
+                        The length of the string can be specified within braces directly following the
+            			pattern specifier, e.g. <b>%random{8}</b> would output an 8 character string.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>username</term>
+                    <description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>utcdate</term>
+                    <description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Util.PatternString"/>
+            instance using <see cref="M:AddConverter(ConverterInfo)"/> or
+            <see cref="M:AddConverter(string, Type)"/>.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.PatternLayout"/> for details on the 
+            <i>format modifiers</i> supported by the patterns.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternString.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternString only
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor(System.String)">
+            <summary>
+            Constructs a PatternString
+            </summary>
+            <param name="pattern">The pattern to use with this PatternString</param>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/> with the pattern specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.ActivateOptions">
+            <summary>
+            Initialize object options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternString.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternString.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternString.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.CreatePatternParser(System.String)">
+            <summary>
+            Create the <see cref="T:log4net.Util.PatternParser"/> used to parse the pattern
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/></returns>
+            <remarks>
+            <para>
+            Returns PatternParser used to parse the conversion string. Subclasses
+            may override this to return a subclass of PatternParser which recognize
+            custom conversion pattern name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format(System.IO.TextWriter)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the pattern to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format">
+            <summary>
+            Format the pattern as a string
+            </summary>
+            <returns>the pattern formatted as a string</returns>
+            <remarks>
+            <para>
+            Format the pattern to a string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a converter to this PatternString
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternString.ConversionPattern">
+            <summary>
+            Gets or sets the pattern formatting string
+            </summary>
+            <value>
+            The pattern formatting string
+            </value>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PropertiesDictionary">
+            <summary>
+            String keyed object map.
+            </summary>
+            <remarks>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.ReadOnlyPropertiesDictionary">
+            <summary>
+            String keyed object map that is read only.
+            </summary>
+            <remarks>
+            <para>
+            This collection is readonly and cannot be modified.
+            </para>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.ReadOnlyPropertiesDictionary.m_hashtable">
+            <summary>
+            The Hashtable used to store the properties data
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Copy Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Deserialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetKeys">
+            <summary>
+            Gets the key names.
+            </summary>
+            <returns>An array of all the keys.</returns>
+            <remarks>
+            <para>
+            Gets the key names.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Contains(System.String)">
+            <summary>
+            Test if the dictionary contains a specified key
+            </summary>
+            <param name="key">the key to look for</param>
+            <returns>true if the dictionary contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if the dictionary contains a specified key
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <param name="value"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.InnerHashtable">
+            <summary>
+            The hashtable used to store the properties
+            </summary>
+            <value>
+            The internal collection used to store the properties
+            </value>
+            <remarks>
+            <para>
+            The hashtable used to store the properties
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Count">
+            <summary>
+            The number of properties in this collection
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class 
+            with serialized data.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Because this class is sealed the serialization constructor is private.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Remove(System.String)">
+            <summary>
+            Remove the entry with the specified key from this dictionary
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+            <returns>an enumerator</returns>
+            <remarks>
+            <para>
+            Returns a <see cref="T:System.Collections.IDictionaryEnumerator"/> over the contest of this collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key">the key to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key">the key to lookup in the collection</param>
+            <returns><c>true</c> if the collection contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if this collection contains a specified key.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+            <remarks>
+            <para>
+            Remove all properties from the properties collection
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key">the key</param>
+            <param name="value">the value to store for the key</param>
+            <remarks>
+            <para>
+            Store a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+            <value>
+            <c>false</c>
+            </value>
+            <remarks>
+            <para>
+            This collection is modifiable. This property always
+            returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+            <value>
+            The value for the key specified.
+            </value>
+            <remarks>
+            <para>
+            Get or set a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="T:log4net.Util.PropertyEntry">
+            <summary>
+            A class to hold the key and data for a property set in the config file
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the key and data for a property set in the config file
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertyEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Key">
+            <summary>
+            Property Key
+            </summary>
+            <value>
+            Property Key
+            </value>
+            <remarks>
+            <para>
+            Property Key.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Value">
+            <summary>
+            Property Value
+            </summary>
+            <value>
+            Property Value
+            </value>
+            <remarks>
+            <para>
+            Property Value.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ProtectCloseTextWriter">
+            <summary>
+            A <see cref="T:System.IO.TextWriter"/> that ignores the <see cref="M:log4net.Util.ProtectCloseTextWriter.Close"/> message
+            </summary>
+            <remarks>
+            <para>
+            This writer is used in special cases where it is necessary 
+            to protect a writer from being closed by a client.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <remarks>
+            <para>
+            Create a new ProtectCloseTextWriter using a writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Attach(System.IO.TextWriter)">
+            <summary>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to attach to</param>
+            <remarks>
+            <para>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Close">
+            <summary>
+            Does not close the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Does not close the underlying output writer.
+            This method does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReaderWriterLock">
+            <summary>
+            Defines a lock that supports single writers and multiple readers
+            </summary>
+            <remarks>
+            <para>
+            <c>ReaderWriterLock</c> is used to synchronize access to a resource. 
+            At any given time, it allows either concurrent read access for 
+            multiple threads, or write access for a single thread. In a 
+            situation where a resource is changed infrequently, a 
+            <c>ReaderWriterLock</c> provides better throughput than a simple 
+            one-at-a-time lock, such as <see cref="T:System.Threading.Monitor"/>.
+            </para>
+            <para>
+            If a platform does not support a <c>System.Threading.ReaderWriterLock</c> 
+            implementation then all readers and writers are serialized. Therefore 
+            the caller must not rely on multiple simultaneous readers.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReaderWriterLock"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireReaderLock">
+            <summary>
+            Acquires a reader lock
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.AcquireReaderLock"/> blocks if a different thread has the writer 
+            lock, or if at least one thread is waiting for the writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock">
+            <summary>
+            Decrements the lock count
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock"/> decrements the lock count. When the count 
+            reaches zero, the lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireWriterLock">
+            <summary>
+            Acquires the writer lock
+            </summary>
+            <remarks>
+            <para>
+            This method blocks if another thread has a reader lock or writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseWriterLock">
+            <summary>
+            Decrements the lock count on the writer lock
+            </summary>
+            <remarks>
+            <para>
+            ReleaseWriterLock decrements the writer lock count. 
+            When the count reaches zero, the writer lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReusableStringWriter">
+            <summary>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.
+            This uses a single buffer for string operations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </summary>
+            <param name="formatProvider">the format provider to use</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">
+            <summary>
+            Override Dispose to prevent closing of writer
+            </summary>
+            <param name="disposing">flag</param>
+            <remarks>
+            <para>
+            Override Dispose to prevent closing of writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">
+            <summary>
+            Reset this string writer so that it can be reused.
+            </summary>
+            <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>
+            <param name="defaultSize">the default size to make the buffer</param>
+            <remarks>
+            <para>
+            Reset this string writer so that it can be reused.
+            The internal buffers are cleared and reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemInfo">
+            <summary>
+            Utility class for system specific information.
+            </summary>
+            <remarks>
+            <para>
+            Utility class of static methods for system specific information.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Alexey Solofnenko</author>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#ctor">
+            <summary>
+            Private constructor to prevent instances.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#cctor">
+            <summary>
+            Initialize default values for private static fields.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyLocationInfo(System.Reflection.Assembly)">
+            <summary>
+            Gets the assembly location path for the specified assembly.
+            </summary>
+            <param name="myAssembly">The assembly to get the location for.</param>
+            <returns>The location of the assembly.</returns>
+            <remarks>
+            <para>
+            This method does not guarantee to return the correct path
+            to the assembly. If only tries to give an indication as to
+            where the assembly was loaded from.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyQualifiedName(System.Type)">
+            <summary>
+            Gets the fully qualified name of the <see cref="T:System.Type"/>, including 
+            the name of the assembly from which the <see cref="T:System.Type"/> was 
+            loaded.
+            </summary>
+            <param name="type">The <see cref="T:System.Type"/> to get the fully qualified name for.</param>
+            <returns>The fully qualified name for the <see cref="T:System.Type"/>.</returns>
+            <remarks>
+            <para>
+            This is equivalent to the <c>Type.AssemblyQualifiedName</c> property,
+            but this method works on the .NET Compact Framework 1.0 as well as
+            the full .NET runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyShortName(System.Reflection.Assembly)">
+            <summary>
+            Gets the short name of the <see cref="T:System.Reflection.Assembly"/>.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the name for.</param>
+            <returns>The short name of the <see cref="T:System.Reflection.Assembly"/>.</returns>
+            <remarks>
+            <para>
+            The short name of the assembly is the <see cref="P:System.Reflection.Assembly.FullName"/> 
+            without the version, culture, or public key. i.e. it is just the 
+            assembly's file name without the extension.
+            </para>
+            <para>
+            Use this rather than <c>Assembly.GetName().Name</c> because that
+            is not available on the Compact Framework.
+            </para>
+            <para>
+            Because of a FileIOPermission security demand we cannot do
+            the obvious Assembly.GetName().Name. We are allowed to get
+            the <see cref="P:System.Reflection.Assembly.FullName"/> of the assembly so we 
+            start from there and strip out just the assembly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyFileName(System.Reflection.Assembly)">
+            <summary>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the file name for.</param>
+            <returns>The file name of the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Type,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeType">A sibling type to use to load the type.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified, it will be loaded from the assembly
+            containing the specified relative type. If the type is not found in the assembly 
+            then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>		
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the
+            assembly that is directly calling this method. If the type is not found 
+            in the assembly then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Reflection.Assembly,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeAssembly">An assembly to load the type from.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the specified
+            assembly. If the type is not found in the assembly then all the loaded assemblies 
+            will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.NewGuid">
+            <summary>
+            Generate a new guid
+            </summary>
+            <returns>A new Guid</returns>
+            <remarks>
+            <para>
+            Generate a new guid
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateArgumentOutOfRangeException(System.String,System.Object,System.String)">
+            <summary>
+            Create an <see cref="T:System.ArgumentOutOfRangeException"/>
+            </summary>
+            <param name="parameterName">The name of the parameter that caused the exception</param>
+            <param name="actualValue">The value of the argument that causes this exception</param>
+            <param name="message">The message that describes the error</param>
+            <returns>the ArgumentOutOfRangeException object</returns>
+            <remarks>
+            <para>
+            Create a new instance of the <see cref="T:System.ArgumentOutOfRangeException"/> class 
+            with a specified error message, the parameter name, and the value 
+            of the argument.
+            </para>
+            <para>
+            The Compact Framework does not support the 3 parameter constructor for the
+            <see cref="T:System.ArgumentOutOfRangeException"/> type. This method provides an
+            implementation that works for all platforms.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int32@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int32"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int64@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int64"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int16@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int16"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetAppSetting(System.String)">
+            <summary>
+            Lookup an application setting
+            </summary>
+            <param name="key">the application settings key to lookup</param>
+            <returns>the value for the key, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Configuration APIs are not supported under the Compact Framework
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified local file path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            <para>
+            The path specified must be a local file path, a URI is not supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateCaseInsensitiveHashtable">
+            <summary>
+            Creates a new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity. 
+            </summary>
+            <returns>A new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity</returns>
+            <remarks>
+            <para>
+            The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.EqualsIgnoringCase(System.String,System.String)">
+            <summary>
+            Tests two strings for equality, the ignoring case.
+            </summary>
+            <remarks>
+            If the platform permits, culture information is ignored completely (ordinal comparison).
+            The aim of this method is to provide a fast comparison that deals with <c>null</c> and ignores different casing.
+            It is not supposed to deal with various, culture-specific habits.
+            Use it to compare against pure ASCII constants, like keywords etc.
+            </remarks>
+            <param name="a">The one string.</param>
+            <param name="b">The other string.</param>
+            <returns><c>true</c> if the strings are equal, <c>false</c> otherwise.</returns>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.EmptyTypes">
+            <summary>
+            Gets an empty array of types.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Type.EmptyTypes</c> field is not available on
+            the .NET Compact Framework 1.0.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.declaringType">
+            <summary>
+            The fully qualified type of the SystemInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_hostName">
+            <summary>
+            Cache the host name for the current machine
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_appFriendlyName">
+            <summary>
+            Cache the application friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_nullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_notAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_processStartTimeUtc">
+            <summary>
+            Start time for the current process.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NewLine">
+            <summary>
+            Gets the system dependent line terminator.
+            </summary>
+            <value>
+            The system dependent line terminator.
+            </value>
+            <remarks>
+            <para>
+            Gets the system dependent line terminator.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationBaseDirectory">
+            <summary>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The base directory path for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ConfigurationFileLocation">
+            <summary>
+            Gets the path to the configuration file for the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the configuration file for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            The .NET Compact Framework 1.0 does not have a concept of a configuration
+            file. For this runtime, we use the entry assembly location as the root for
+            the configuration file name.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.EntryAssemblyLocation">
+            <summary>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the entry assembly.</value>
+            <remarks>
+            <para>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.CurrentThreadId">
+            <summary>
+            Gets the ID of the current thread.
+            </summary>
+            <value>The ID of the current thread.</value>
+            <remarks>
+            <para>
+            On the .NET framework, the <c>AppDomain.GetCurrentThreadId</c> method
+            is used to obtain the thread ID for the current thread. This is the 
+            operating system ID for the thread.
+            </para>
+            <para>
+            On the .NET Compact Framework 1.0 it is not possible to get the 
+            operating system thread ID for the current thread. The native method 
+            <c>GetCurrentThreadId</c> is implemented inline in a header file
+            and cannot be called.
+            </para>
+            <para>
+            On the .NET Framework 2.0 the <c>Thread.ManagedThreadId</c> is used as this
+            gives a stable id unrelated to the operating system thread ID which may 
+            change if the runtime is using fibers.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.HostName">
+            <summary>
+            Get the host name or machine name for the current machine
+            </summary>
+            <value>
+            The hostname or machine name
+            </value>
+            <remarks>
+            <para>
+            Get the host name or machine name for the current machine
+            </para>
+            <para>
+            The host name (<see cref="M:System.Net.Dns.GetHostName"/>) or
+            the machine name (<c>Environment.MachineName</c>) for
+            the current machine, or if neither of these are available
+            then <c>NOT AVAILABLE</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationFriendlyName">
+            <summary>
+            Get this application's friendly name
+            </summary>
+            <value>
+            The friendly name of this application as a string
+            </value>
+            <remarks>
+            <para>
+            If available the name of the application is retrieved from
+            the <c>AppDomain</c> using <c>AppDomain.CurrentDomain.FriendlyName</c>.
+            </para>
+            <para>
+            Otherwise the file name of the entry assembly is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTime">
+            <summary>
+            Get the start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTimeUtc">
+            <summary>
+            Get the UTC start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the UTC time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+            <remarks>
+            <para>
+            Use this value to indicate a <c>null</c> has been encountered while
+            outputting a string representation of an item.
+            </para>
+            <para>
+            The default value is <c>(null)</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NullText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NotAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+            <remarks>
+            <para>
+            Use this value when an unsupported feature is requested.
+            </para>
+            <para>
+            The default value is <c>NOT AVAILABLE</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NotAvailableText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemStringFormat">
+            <summary>
+            Utility class that represents a format string.
+            </summary>
+            <remarks>
+            <para>
+            Utility class that represents a format string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.#ctor(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Initialise the <see cref="T:log4net.Util.SystemStringFormat"/>
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.ToString">
+            <summary>
+            Format the string and arguments
+            </summary>
+            <returns>the formatted string</returns>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Replaces the format item in a specified <see cref="T:System.String"/> with the text equivalent 
+            of the value of a corresponding <see cref="T:System.Object"/> instance in a specified array.
+            A specified parameter supplies culture-specific formatting information.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+            <returns>
+            A copy of format in which the format items have been replaced by the <see cref="T:System.String"/> 
+            equivalent of the corresponding instances of <see cref="T:System.Object"/> in args.
+            </returns>
+            <remarks>
+            <para>
+            This method does not throw exceptions. If an exception thrown while formatting the result the
+            exception and arguments are returned in the result string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormatError(System.Exception,System.String,System.Object[])">
+            <summary>
+            Process an error during StringFormat
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderArray(System.Array,System.Text.StringBuilder)">
+            <summary>
+            Dump the contents of an array into a string builder
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderObject(System.Object,System.Text.StringBuilder)">
+            <summary>
+            Dump an object to a string
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemStringFormat.declaringType">
+            <summary>
+            The fully qualified type of the SystemStringFormat class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextProperties._dictionary">
+            <summary>
+            Each thread will automatically have its instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove a property
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetKeys">
+            <summary>
+            Get the keys stored in the properties.
+            </summary>
+            <para>
+            Gets the keys stored in the properties.
+            </para>
+            <returns>a set of the defined keys</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Clear">
+            <summary>
+            Clear all properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the <c>PropertiesDictionary</c> for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this tread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.ThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.ThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.ThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameStack">
+            <summary>
+            The ThreadContextStack internal stack
+            </summary>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.#ctor(System.Collections.Stack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.Transform">
+            <summary>
+            Utility class for transforming strings.
+            </summary>
+            <remarks>
+            <para>
+            Utility class for transforming strings.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.Transform.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.Transform"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.WriteEscapedXmlString(System.Xml.XmlWriter,System.String,System.String)">
+            <summary>
+            Write a string to an <see cref="T:System.Xml.XmlWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="textData">the string to write</param>
+            <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param>
+            <remarks>
+            <para>
+            The test is escaped either using XML escape entities
+            or using CDATA sections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.MaskXmlInvalidCharacters(System.String,System.String)">
+            <summary>
+            Replace invalid XML characters in text string
+            </summary>
+            <param name="textData">the XML text input string</param>
+            <param name="mask">the string to use in place of invalid characters</param>
+            <returns>A string that does not contain invalid XML characters.</returns>
+            <remarks>
+            <para>
+            Certain Unicode code points are not allowed in the XML InfoSet, for
+            details see: <a href="http://www.w3.org/TR/REC-xml/#charsets">http://www.w3.org/TR/REC-xml/#charsets</a>.
+            </para>
+            <para>
+            This method replaces any illegal characters in the input string
+            with the mask string specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.CountSubstrings(System.String,System.String)">
+            <summary>
+            Count the number of times that the substring occurs in the text
+            </summary>
+            <param name="text">the text to search</param>
+            <param name="substring">the substring to find</param>
+            <returns>the number of times the substring occurs in the text</returns>
+            <remarks>
+            <para>
+            The substring is assumed to be non repeating within itself.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.Transform.INVALIDCHARS">
+            <summary>
+            Characters illegal in XML 1.0
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext">
+            <summary>
+            Impersonate a Windows Account
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.SecurityContext"/> impersonates a Windows account.
+            </para>
+            <para>
+            How the impersonation is done depends on the value of <see cref="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)"/>.
+            This allows the context to either impersonate a set of user credentials specified 
+            using username, domain name and password or to revert to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.ActivateOptions">
+            <summary>
+            Initialize the SecurityContext based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The security context will try to Logon the specified user account and
+            capture a primary token for impersonation.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, 
+            <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> or <see cref="P:log4net.Util.WindowsSecurityContext.Password"/> properties were not specified.</exception>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.
+            </summary>
+            <param name="state">caller provided state</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> instance that will revoke the impersonation of this SecurityContext
+            </returns>
+            <remarks>
+            <para>
+            Depending on the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property either
+            impersonate a user using credentials supplied or revert 
+            to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.LogonUser(System.String,System.String,System.String)">
+            <summary>
+            Create a <see cref="T:System.Security.Principal.WindowsIdentity"/> given the userName, domainName and password.
+            </summary>
+            <param name="userName">the user name</param>
+            <param name="domainName">the domain name</param>
+            <param name="password">the password</param>
+            <returns>the <see cref="T:System.Security.Principal.WindowsIdentity"/> for the account specified</returns>
+            <remarks>
+            <para>
+            Uses the Windows API call LogonUser to get a principal token for the account. This
+            token is used to initialize the WindowsIdentity.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Credentials">
+            <summary>
+            Gets or sets the impersonation mode for this security context
+            </summary>
+            <value>
+            The impersonation mode for this security context
+            </value>
+            <remarks>
+            <para>
+            Impersonate either a user with user credentials or
+            revert this thread to the credentials of the process.
+            The value is one of the <see cref="T:log4net.Util.WindowsSecurityContext.ImpersonationMode"/>
+            enum.
+            </para>
+            <para>
+            The default value is <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            the user's credentials are established using the
+            <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.Password"/>
+            values.
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process"/>
+            no other properties need to be set. If the calling thread is 
+            impersonating then it will be reverted back to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.UserName">
+            <summary>
+            Gets or sets the Windows username for this security context
+            </summary>
+            <value>
+            The Windows username for this security context
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.DomainName">
+            <summary>
+            Gets or sets the Windows domain name for this security context
+            </summary>
+            <value>
+            The Windows domain name for this security context
+            </value>
+            <remarks>
+            <para>
+            The default value for <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> is the local machine name
+            taken from the <see cref="P:System.Environment.MachineName"/> property.
+            </para>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Password">
+            <summary>
+            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.
+            </summary>
+            <value>
+            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.
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.ImpersonationMode">
+            <summary>
+            The impersonation modes for the <see cref="T:log4net.Util.WindowsSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            See the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property for
+            details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User">
+            <summary>
+            Impersonate a user using the credentials supplied
+            </summary>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process">
+            <summary>
+            Revert this the thread to the credentials of the process
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext">
+            <summary>
+            Adds <see cref="T:System.IDisposable"/> to <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Helper class to expose the <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            through the <see cref="T:System.IDisposable"/> interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.#ctor(System.Security.Principal.WindowsImpersonationContext)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="impersonationContext">the impersonation context being wrapped</param>
+            <remarks>
+            <para>
+            Constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.Dispose">
+            <summary>
+            Revert the impersonation
+            </summary>
+            <remarks>
+            <para>
+            Revert the impersonation
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.GlobalContext">
+            <summary>
+            The log4net Global Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>GlobalContext</c> provides a location for global debugging 
+            information to be stored.
+            </para>
+            <para>
+            The global context has a properties map and these properties can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputing these properties.
+            </para>
+            <para>
+            By default the <c>log4net:HostName</c> property is set to the name of 
+            the current machine.
+            </para>
+            </remarks>
+            <example>
+            <code lang="C#">
+            GlobalContext.Properties["hostname"] = Environment.MachineName;
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.GlobalContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="F:log4net.GlobalContext.s_properties">
+            <summary>
+            The global context properties instance
+            </summary>
+        </member>
+        <member name="P:log4net.GlobalContext.Properties">
+            <summary>
+            The global properties map.
+            </summary>
+            <value>
+            The global properties map.
+            </value>
+            <remarks>
+            <para>
+            The global properties map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.AssemblyInfo">
+            <summary>
+            Provides information about the environment the assembly has
+            been built for.
+            </summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.Version">
+            <summary>Version of the assembly</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFrameworkVersion">
+            <summary>Version of the framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFramework">
+            <summary>Type of framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.ClientProfile">
+            <summary>Does it target a client profile?</summary>
+        </member>
+        <member name="P:log4net.AssemblyInfo.Info">
+            <summary>
+            Identifies the version and target for this assembly.
+            </summary>
+        </member>
+        <member name="T:log4net.LogicalThreadContext">
+            <summary>
+            The log4net Logical Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> provides a location for <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> specific debugging 
+            information to be stored.
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> or <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The Logical Thread Context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Logical Thread Context provides a diagnostic context for the current call context. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Logical Thread Context is managed on a per <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> basis.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            LogicalThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a LogicalThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.LogicalThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> 
+            or <see cref="T:log4net.GlobalContext"/> properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The logical thread stacks.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.LogManager">
+            <summary>
+            This class is used by client applications to request logger instances.
+            </summary>
+            <remarks>
+            <para>
+            This class has static methods that are used by a client to request
+            a logger instance. The <see cref="M:GetLogger(string)"/> method is 
+            used to retrieve a logger.
+            </para>
+            <para>
+            See the <see cref="T:log4net.ILog"/> interface for more details.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <seealso cref="T:log4net.ILog"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.LogManager.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.LogManager"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String)">
+            <overloads>Returns the named logger if it exists.</overloads>
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the default repository) then it
+            returns a reference to the logger, otherwise it returns <c>null</c>.
+            </para>
+            </remarks>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>The logger found, or <c>null</c> if no logger could be found.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers">
+            <overloads>Get the currently defined loggers.</overloads>
+            <summary>
+            Returns all the currently defined loggers in the default repository.
+            </summary>
+            <remarks>
+            <para>The root logger is <b>not</b> included in the returned array.</para>
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String)">
+            <overloads>Get or create a logger.</overloads>
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the logger doesn't exist in the specified 
+            repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the repository for the specified assembly) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger, or <c>null</c> if the logger doesn't exist in the specified
+            assembly's repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Get the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository">
+            <overloads>Shutdown a logger repository.</overloads>
+            <summary>
+            Shuts down the default repository.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            default repository.
+            </para>
+            <para>Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repository">The repository to shutdown.</param>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration">
+            <overloads>Reset the configuration of a repository</overloads>
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repository">The repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository">
+            <overloads>Get the logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository">
+            <overloads>Get a logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Type)">
+            <overloads>Create a domain</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Type)">
+            <overloads>Create a logger repository.</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetAllRepositories">
+            <summary>
+            Gets the list of currently defined repositories.
+            </summary>
+            <remarks>
+            <para>
+            Get an array of all the <see cref="T:log4net.Repository.ILoggerRepository"/> objects that have been created.
+            </para>
+            </remarks>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Flush(System.Int32)">
+            <summary>
+            Flushes logging events buffered in all configured appenders in the default repository.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLogger(log4net.Core.ILogger)">
+            <summary>
+            Looks up the wrapper object for the logger specified.
+            </summary>
+            <param name="logger">The logger to get the wrapper for.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLoggers(log4net.Core.ILogger[])">
+            <summary>
+            Looks up the wrapper objects for the loggers specified.
+            </summary>
+            <param name="loggers">The loggers to get the wrappers for.</param>
+            <returns>The wrapper objects for the loggers specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapperCreationHandler(log4net.Core.ILogger)">
+            <summary>
+            Create the <see cref="T:log4net.Core.ILoggerWrapper"/> objects used by
+            this manager.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="F:log4net.LogManager.s_wrapperMap">
+            <summary>
+            The wrapper map to use to hold the <see cref="T:log4net.Core.LogImpl"/> objects.
+            </summary>
+        </member>
+        <member name="T:log4net.MDC">
+            <summary>
+            Implementation of Mapped Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is
+            based on a map instead of a stack. It provides <i>mapped
+            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or
+            MDC in short, is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The MDC is managed on a per thread basis.
+            </para>
+            </remarks>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.MDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.MDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Get(System.String)">
+            <summary>
+            Gets the context value identified by the <paramref name="key"/> parameter.
+            </summary>
+            <param name="key">The key to lookup in the MDC.</param>
+            <returns>The string value held for the key, or a <c>null</c> reference if no corresponding value is found.</returns>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            If the <paramref name="key"/> parameter does not look up to a
+            previously defined context then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Set(System.String,System.String)">
+            <summary>
+            Add an entry to the MDC
+            </summary>
+            <param name="key">The key to store the value under.</param>
+            <param name="value">The value to store.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Puts a context value (the <paramref name="value"/> parameter) as identified
+            with the <paramref name="key"/> parameter into the current thread's
+            context map.
+            </para>
+            <para>
+            If a value is already defined for the <paramref name="key"/>
+            specified then the value will be replaced. If the <paramref name="value"/> 
+            is specified as <c>null</c> then the key value mapping will be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Remove(System.String)">
+            <summary>
+            Removes the key value mapping for the key specified.
+            </summary>
+            <param name="key">The key to remove.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove the specified entry from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Clear">
+            <summary>
+            Clear all entries in the MDC
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove all the entries from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.NDC">
+            <summary>
+            Implementation of Nested Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            A Nested Diagnostic Context, or NDC in short, is an instrument
+            to distinguish interleaved log output from different sources. Log
+            output is typically interleaved when a server handles multiple
+            clients near-simultaneously.
+            </para>
+            <para>
+            Interleaved log output can still be meaningful if each log entry
+            from different contexts had a distinctive stamp. This is where NDCs
+            come into play.
+            </para>
+            <para>
+            Note that NDCs are managed on a per thread basis. The NDC class
+            is made up of static methods that operate on the context of the
+            calling thread.
+            </para>
+            </remarks>
+            <example>How to push a message into the context
+            <code lang="C#">
+            using(NDC.Push("my context message"))
+            {
+            	... all log calls will have 'my context message' included ...
+            
+            } // at the end of the using block the message is automatically removed 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.NDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.NDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Clear">
+            <summary>
+            Clears all the contextual information held on the current thread.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Clears the stack of NDC data held on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.CloneStack">
+            <summary>
+            Creates a clone of the stack of context information.
+            </summary>
+            <returns>A clone of the context info for this thread.</returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The results of this method can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> 
+            method to allow child threads to inherit the context of their 
+            parent thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">
+            <summary>
+            Inherits the contextual information from another thread.
+            </summary>
+            <param name="stack">The context stack to inherit.</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This thread will use the context information from the stack
+            supplied. This can be used to initialize child threads with
+            the same contextual information as their parent threads. These
+            contexts will <b>NOT</b> be shared. Any further contexts that
+            are pushed onto the stack will not be visible to the other.
+            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to
+            this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Pop">
+            <summary>
+            Removes the top context from the stack.
+            </summary>
+            <returns>
+            The message in the context that was removed from the top 
+            of the stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Remove the top context from the stack, and return
+            it to the caller. If the stack is empty then an
+            empty string (not <c>null</c>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Push(System.String)">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.NDC.Push("NDC_Message"))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.PushFormat(System.String,System.Object[])">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="messageFormat">The new context message string format.</param>
+            <param name="args">Arguments to be passed into messageFormat.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            var someValue = "ExampleContext"
+            using(log4net.NDC.PushFormat("NDC_Message {0}", someValue))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.Remove">
+            <summary>
+            Removes the context information for this thread. It is
+            not required to call this method.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This method is not implemented.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">
+            <summary>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            </summary>
+            <param name="maxDepth">The maximum depth of the stack</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            This may truncate the head of the stack. This only affects the 
+            stack in the current thread. Also it does not prevent it from
+            growing, it only sets the maximum depth at the time of the
+            call. This can be used to return to a known context depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.NDC.Depth">
+            <summary>
+            Gets the current context depth.
+            </summary>
+            <value>The current context depth.</value>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The number of context values pushed onto the context stack.
+            </para>
+            <para>
+            Used to record the current depth of the context. This can then 
+            be restored using the <see cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/> method.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/>
+        </member>
+        <member name="T:log4net.ThreadContext">
+            <summary>
+            The log4net Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> provides a location for thread specific debugging 
+            information to be stored.
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            The thread context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Thread Context provides a diagnostic context for the current thread. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Thread Context is managed on a per thread basis.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            ThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a ThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(ThreadContext.Stacks["NDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a ThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.ThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.ThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.ThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.ThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The thread local stacks.
+            </para>
+            </remarks>
+        </member>
+    </members>
+</doc>
diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-full/log4net.dll b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-full/log4net.dll
new file mode 100644
index 0000000000000000000000000000000000000000..24affb7feeddb42e27ab32c6f3bfe1ff73017acf
GIT binary patch
literal 286720
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
SF>o0Jmoab|1OI7a;Qt2$ai(7Y

literal 0
HcmV?d00001

diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-full/log4net.xml b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-full/log4net.xml
new file mode 100644
index 000000000..18f17674e
--- /dev/null
+++ b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net35-full/log4net.xml
@@ -0,0 +1,32464 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>log4net</name>
+    </assembly>
+    <members>
+        <member name="T:log4net.Appender.AdoNetAppender">
+            <summary>
+            Appender that logs to a database.
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
+            database. The appender can be configured to specify the connection 
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
+            property. For more information on database connection strings for
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
+            </para>
+            <para>
+            Records are written into the database either using a prepared
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
+            procedure.
+            </para>
+            <para>
+            The prepared statement text or the name of the stored procedure
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
+            </para>
+            <para>
+            The prepared statement or stored procedure can take a number
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
+            type may be subclassed if required to provide database specific
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
+            the parameter name, database type, size, and how the value should
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
+            </para>
+            </remarks>
+            <example>
+            An example of a SQL Server table that could be logged to:
+            <code lang="SQL">
+            CREATE TABLE [dbo].[Log] ( 
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,
+              [Date] [datetime] NOT NULL ,
+              [Thread] [varchar] (255) NOT NULL ,
+              [Level] [varchar] (20) NOT NULL ,
+              [Logger] [varchar] (255) NOT NULL ,
+              [Message] [varchar] (4000) NOT NULL 
+            ) ON [PRIMARY]
+            </code>
+            </example>
+            <example>
+            An example configuration to log to the above table:
+            <code lang="XML" escaped="true">
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
+              <parameter>
+                <parameterName value="@log_date"/>
+                <dbType value="DateTime"/>
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@thread"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@log_level"/>
+                <dbType value="String"/>
+                <size value="50"/>
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@logger"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@message"/>
+                <dbType value="String"/>
+                <size value="4000"/>
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>
+              </parameter>
+            </appender>
+            </code>
+            </example>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Lance Nehring</author>
+        </member>
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
+            buffers events in a fixed size buffer.
+            </summary>
+            <remarks>
+            <para>
+            This base class should be used by appenders that need to buffer a 
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            buffers events and then submits the entire contents of the buffer to 
+            the underlying database in one go.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:SendBuffer(LoggingEvent[])"/>
+            method to deliver the buffered events.
+            </para>
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
+            buffer of events. The size of the buffer is set using 
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
+            </para>
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
+            triggers, then the current buffer is sent immediately 
+            (see <see cref="M:SendBuffer(LoggingEvent[])"/>). Otherwise the event 
+            is stored in the buffer. For example, an evaluator can be used to 
+            deliver the events immediately when an ERROR event arrives.
+            </para>
+            <para>
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
+            By default the appender is NOT lossy. When the buffer is full all 
+            the buffered events are sent with <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
+            buffer will not be sent when it is full, and new events arriving 
+            in the appender will overwrite the oldest event in the buffer. 
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
+            triggers. This can be useful behavior when you need to know about 
+            ERROR events but not about events with a lower level, configure an 
+            evaluator that will trigger when an ERROR event arrives, the whole 
+            buffer will be sent which gives a history of events leading up to
+            the ERROR event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.AppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
+            </summary>
+            <remarks>
+            <para>
+            This class provides the code for common functionality, such 
+            as support for threshold filtering and support for general filters.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.IAppender">
+            <summary>
+            Implement this interface for your own strategies for printing log statements.
+            </summary>
+            <remarks>
+            <para>
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
+            class which provides a default implementation of this interface.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.IAppender.Close">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logging event in Appender specific way.
+            </summary>
+            <param name="loggingEvent">The event to log</param>
+            <remarks>
+            <para>
+            This method is called to log a message into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.IAppender.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>The name uniquely identifies the appender.</para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IBulkAppender">
+            <summary>
+            Interface for appenders that support bulk logging.
+            </summary>
+            <remarks>
+            <para>
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
+            should only implement this interface if they can bulk log efficiently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Log the array of logging events in Appender specific way.
+            </summary>
+            <param name="loggingEvents">The events to log</param>
+            <remarks>
+            <para>
+            This method is called to log an array of events into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IOptionHandler">
+            <summary>
+            Interface used to delay activate a configured object.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
+            must be called by the container after its all the configured properties have been set 
+            and before the component can be used.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
+            <summary>
+            Activate the options that were previously set with calls to properties.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then this method must be called
+            after its properties have been set before the component can be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IFlushable">
+            <summary>
+            Interface that can be implemented by Appenders that buffer logging data and expose a <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.IFlushable.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            Appenders that implement the <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method must do so in a thread-safe manner: it can be called concurrently with
+            the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            <para>
+            Typically this is done by locking on the Appender instance, e.g.:
+            <code>
+            <![CDATA[
+            public bool Flush(int millisecondsTimeout)
+            {
+                lock(this)
+                {
+                    // Flush buffered logging data
+                    ...
+                }
+            }
+            ]]>
+            </code>
+            </para>
+            <para>
+            The <paramref name="millisecondsTimeout"/> parameter is only relevant for appenders that process logging events asynchronously,
+            such as <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            </remarks>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>Empty default constructor</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
+            <summary>
+            Finalizes this appender by calling the implementation's 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
+            </summary>
+            <remarks>
+            <para>
+            If this appender has not been closed then the <c>Finalize</c> method
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">
+            <summary>
+            Closes the appender and release resources.
+            </summary>
+            <remarks>
+            <para>
+            Release any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            <para>
+            This method cannot be overridden by subclasses. This method 
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
+            method which must be overridden in the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent)"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>
+            will be passed to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent[])"/> method.
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent[])"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvents"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvents"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>
+            will be passed to the <see cref="M:Append(LoggingEvent[])"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if the logging event should we output by this appender
+            </summary>
+            <param name="loggingEvent">the event to test</param>
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
+            <remarks>
+            <para>
+            This method checks the logging event against the threshold level set
+            on this appender and also against the filters specified on this
+            appender.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
+            <summary>
+            Adds a filter to the end of the filter chain.
+            </summary>
+            <param name="filter">the filter to add to this appender</param>
+            <remarks>
+            <para>
+            The Filters are organized in a linked list.
+            </para>
+            <para>
+            Setting this property causes the new filter to be pushed onto the 
+            back of the filter chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
+            <summary>
+            Clears the filter list for this appender.
+            </summary>
+            <remarks>
+            <para>
+            Clears the filter list for this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
+            <summary>
+            Checks if the message level is below this appender's threshold.
+            </summary>
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
+            <remarks>
+            <para>
+            If there is no threshold set, then the return value is always <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
+            requirements of this appender.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
+            <summary>
+            Is called when the appender is closed. Derived classes should override 
+            this method if resources need to be released.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
+            to perform actual logging.
+            </summary>
+            <param name="loggingEvent">The event to append.</param>
+            <remarks>
+            <para>
+            A subclass must implement this method to perform
+            logging of the <paramref name="loggingEvent"/>.
+            </para>
+            <para>This method will be called by <see cref="M:DoAppend(LoggingEvent)"/>
+            if all the conditions listed for that method are met.
+            </para>
+            <para>
+            To restrict the logging of events in the appender
+            override the <see cref="M:PreAppendCheck()"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append a bulk array of logging events.
+            </summary>
+            <param name="loggingEvents">the array of logging events</param>
+            <remarks>
+            <para>
+            This base class implementation calls the <see cref="M:Append(LoggingEvent)"/>
+            method for each element in the bulk array.
+            </para>
+            <para>
+            A sub class that can better process a bulk array of events should
+            override this method in addition to <see cref="M:Append(LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
+            <summary>
+            Called before <see cref="M:Append(LoggingEvent)"/> as a precondition.
+            </summary>
+            <remarks>
+            <para>
+            This method is called by <see cref="M:DoAppend(LoggingEvent)"/>
+            before the call to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            This method can be overridden in a subclass to extend the checks 
+            made before the event is passed to the <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            A subclass should ensure that they delegate this call to
+            this base class if it is overridden.
+            </para>
+            </remarks>
+            <returns><c>true</c> if the call to <see cref="M:Append(LoggingEvent)"/> should proceed.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <returns>The event rendered as a string.</returns>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Where possible use the alternative version of this method
+            <see cref="M:RenderLoggingEvent(TextWriter,LoggingEvent)"/>.
+            That method streams the rendering onto an existing Writer
+            which can give better performance if the caller already has
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>
+            where possible. If, however, the caller needs to render the event
+            to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does
+            provide an efficient mechanism for doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            This implementation doesn't flush anything and always returns true
+            </remarks>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
+            <summary>
+            The layout of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
+            <summary>
+            The name of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
+            <summary>
+            The level threshold of this appender.
+            </summary>
+            <remarks>
+            <para>
+            There is no level threshold filtering by default.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
+            <summary>
+            It is assumed and enforced that errorHandler is never null.
+            </summary>
+            <remarks>
+            <para>
+            It is assumed and enforced that errorHandler is never null.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
+            <summary>
+            The first filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>null</c> initially.
+            </para>
+            <para>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
+            <summary>
+            The last filter in the filter chain.
+            </summary>
+            <remarks>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
+            <summary>
+            Flag indicating if this appender is closed.
+            </summary>
+            <remarks>
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
+            <summary>
+            The guard prevents an appender from repeatedly calling its own DoAppend method
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
+            <summary>
+            StringWriter used to render events
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.declaringType">
+            <summary>
+            The fully qualified type of the AppenderSkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
+            <summary>
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
+            </summary>
+            <value>
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
+            </value>
+            <remarks>
+            <para>
+            All log events with lower level than the threshold level are ignored 
+            by the appender.
+            </para>
+            <para>
+            In configuration files this option is specified by setting the
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
+            string, such as "DEBUG", "INFO" and so on.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </summary>
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
+            <summary>
+            The filter chain.
+            </summary>
+            <value>The head of the filter chain filter chain.</value>
+            <remarks>
+            <para>
+            Returns the head Filter. The Filters are organized in a linked list
+            and so all Filters on this Appender are available through the result.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
+            </summary>
+            <value>The layout of the appender.</value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>
+            The name uniquely identifies the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
+            <summary>
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <remarks>
+            <para>
+            In the rather exceptional case, where the appender 
+            implementation admits a layout but can also work without it, 
+            then the appender should return <c>true</c>.
+            </para>
+            <para>
+            This default implementation always returns <c>false</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
+            <summary>
+            The default buffer size.
+            </summary>
+            <remarks>
+            The default size of the cyclic buffer used to store events.
+            This is set to 512 by default.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <param name="eventMustBeFixed">the events passed through this appender must be
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
+            <remarks>
+            <para>
+            Protected constructor to allow subclassing.
+            </para>
+            <para>
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass
+            expects the events delivered to be fixed even if the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <remarks>
+            <para>
+            Flushes any events that have been buffered.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will NOT be flushed to the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
+            <remarks>
+            <para>
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
+            In this case the contents of the buffer will be tested against the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
+            events will be discarded.
+            </para>
+            <para>
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
+            be emptied by calling this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
+            <summary>
+            Close this appender instance.
+            </summary>
+            <remarks>
+            <para>
+            Close this appender instance. If this appender is marked
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
+            the buffer must be sent when the appender is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
+            </para>
+            <para>
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
+            method) if one of the following conditions is met:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>The cyclic buffer is full and this appender is
+            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
+            	</item>
+            	<item>
+            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
+            		it is triggered for the <paramref name="loggingEvent"/>
+            		specified.</description>
+            	</item>
+            </list>
+            <para>
+            Before the event is stored in the buffer it is fixed
+            (see <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/>) to ensure that
+            any data referenced by the event will be valid when the buffer
+            is processed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
+            <summary>
+            Sends the contents of the buffer.
+            </summary>
+            <param name="firstLoggingEvent">The first logging event.</param>
+            <param name="buffer">The buffer containing the events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override this method to process the buffered events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
+            <summary>
+            The size of the cyclic buffer used to hold the logging events.
+            </summary>
+            <remarks>
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
+            <summary>
+            The cyclic buffer used to store the logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
+            <summary>
+            The triggering event evaluator that causes the buffer to be sent immediately.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event causes the entire
+            buffer to be sent immediately. This field can be <c>null</c>, which 
+            indicates that event triggering is not to be done. The evaluator
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
+            <summary>
+            Indicates if the appender should overwrite events in the cyclic buffer 
+            when it becomes full, or if the buffer should be flushed when the 
+            buffer is full.
+            </summary>
+            <remarks>
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
+            be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
+            <summary>
+            The triggering event evaluator filters discarded events.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event that is discarded should
+            really be discarded or if it should be sent to the appenders. 
+            This field can be <c>null</c>, which indicates that all discarded events will
+            be discarded. 
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
+            <summary>
+            The events delivered to the subclass must be fixed.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
+            <summary>
+            Gets or sets a value that indicates whether the appender is lossy.
+            </summary>
+            <value>
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            This appender uses a buffer to store logging events before 
+            delivering them. A triggering event causes the whole buffer
+            to be send to the remote sink. If the buffer overruns before
+            a triggering event then logging events could be lost. Set
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
+            from being lost.
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
+            <summary>
+            Gets or sets the size of the cyclic buffer used to hold the 
+            logging events.
+            </summary>
+            <value>
+            The size of the cyclic buffer used to hold the logging events.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
+            representing the maximum number of logging events to collect in 
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
+            oldest events are deleted as new events are added to the
+            buffer. By default the size of the cyclic buffer is 512 events.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
+            or equal to 1 then no buffering will occur. The logging event
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
+            be buffered.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
+            buffer to be sent immediately.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
+            sent immediately.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is appended to this 
+            appender. If the evaluator triggers then the current buffer will 
+            immediately be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
+            <summary>
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </summary>
+            <value>
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is discarded from this 
+            appender. If the evaluator triggers then the current buffer will immediately 
+            be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating if only part of the logging event data
+            should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the
+            event data to be fixed and serialized. This will improve performance.
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
+            <summary>
+            Gets or sets a the fields that will be fixed in the event
+            </summary>
+            <value>
+            The event fields that will be fixed before the event is buffered
+            </value>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
+            <summary> 
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
+            </summary>
+            <remarks>
+            Public default constructor to initialize a new instance of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
+            <summary>
+            Override the parent method to close the database
+            </summary>
+            <remarks>
+            <para>
+            Closes the database command and database connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Inserts the events into the database.
+            </summary>
+            <param name="events">The events to insert into the database.</param>
+            <remarks>
+            <para>
+            Insert all the events specified in the <paramref name="events"/>
+            array into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
+            <summary>
+            Adds a parameter to the command.
+            </summary>
+            <param name="parameter">The parameter to add to the command.</param>
+            <remarks>
+            <para>
+            Adds a parameter to the ordered list of command parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
+            <summary>
+            Writes the events to the database using the transaction specified.
+            </summary>
+            <param name="dbTran">The transaction that the events will be executed under.</param>
+            <param name="events">The array of events to insert into the database.</param>
+            <remarks>
+            <para>
+            The transaction argument can be <c>null</c> if the appender has been
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
+            property for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
+            <summary>
+            Formats the log message into database statement text.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            This method can be overridden by subclasses to provide 
+            more control over the format of the database statement.
+            </remarks>
+            <returns>
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.CreateConnection(System.Type,System.String)">
+            <summary>
+            Creates an <see cref="T:System.Data.IDbConnection"/> instance used to connect to the database.
+            </summary>
+            <remarks>
+            This method is called whenever a new IDbConnection is needed (i.e. when a reconnect is necessary).
+            </remarks>
+            <param name="connectionType">The <see cref="T:System.Type"/> of the <see cref="T:System.Data.IDbConnection"/> object.</param>
+            <param name="connectionString">The connectionString output from the ResolveConnectionString method.</param>
+            <returns>An <see cref="T:System.Data.IDbConnection"/> instance with a valid connection string.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionString(System.String@)">
+            <summary>
+            Resolves the connection string from the ConnectionString, ConnectionStringName, or AppSettingsKey
+            property.
+            </summary>
+            <remarks>
+            ConnectiongStringName is only supported on .NET 2.0 and higher.
+            </remarks>
+            <param name="connectionStringContext">Additional information describing the connection string.</param>
+            <returns>A connection string used to connect to the database.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
+            <summary>
+            Retrieves the class type of the ADO.NET provider.
+            </summary>
+            <remarks>
+            <para>
+            Gets the Type of the ADO.NET provider to use to connect to the
+            database. This method resolves the type specified in the 
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
+            </para>
+            <para>
+            Subclasses can override this method to return a different type
+            if necessary.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
+            <summary>
+            Connects to the database.
+            </summary>		
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.DiposeConnection">
+            <summary>
+            Cleanup the existing connection.
+            </summary>
+            <remarks>
+            Calls the IDbConnection's <see cref="M:System.Data.IDbConnection.Close"/> method.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
+            <summary>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </summary>
+            <remarks>
+            <para>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
+            <summary>
+            The <see cref="T:System.Data.IDbConnection"/> that will be used
+            to insert logging events into a database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
+            <summary>
+            Database connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_appSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
+            <summary>
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
+            <summary>
+            The text of the command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
+            <summary>
+            The command type.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
+            <summary>
+            Indicates whether to reconnect when a connection is lost.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.declaringType">
+            <summary>
+            The fully qualified type of the AdoNetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
+            <summary>
+            Gets or sets the database connection string that is used to connect to 
+            the database.
+            </summary>
+            <value>
+            The database connection string used to connect to the database.
+            </value>
+            <remarks>
+            <para>
+            The connections string is specific to the connection type.
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
+            </para>
+            </remarks>
+            <example>Connection string for MS Access via ODBC:
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
+            </example>
+            <example>Another connection string for MS Access via ODBC:
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
+            </example>
+            <example>Connection string for MS Access via OLE DB:
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.AppSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+            <remarks>
+            This property requires at least .NET 2.0.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
+            <summary>
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
+            that should be created.
+            </summary>
+            <value>
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
+            </value>
+            <remarks>
+            <para>
+            The type name of the ADO.NET provider to use.
+            </para>
+            <para>
+            The default is to use the OLE DB provider.
+            </para>
+            </remarks>
+            <example>Use the OLE DB Provider. This is the default value.
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the MS SQL Server Provider. 
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the ODBC Provider. 
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>ODBC .NET Data Provider</b>.
+            </example>
+            <example>Use the Oracle Provider. 
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>.NET Managed Provider for Oracle</b>.
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
+            <summary>
+            Gets or sets the command text that is used to insert logging events
+            into the database.
+            </summary>
+            <value>
+            The command text used to insert logging events into the database.
+            </value>
+            <remarks>
+            <para>
+            Either the text of the prepared statement or the
+            name of the stored procedure to execute to write into
+            the database.
+            </para>
+            <para>
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
+            this text is a prepared statement or a stored procedure.
+            </para>
+            <para>
+            If this property is not set, the command text is retrieved by invoking
+            <see cref="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
+            <summary>
+            Gets or sets the command type to execute.
+            </summary>
+            <value>
+            The command type to execute.
+            </value>
+            <remarks>
+            <para>
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
+            to execute.
+            </para>
+            <para>
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
+            <summary>
+            Should transactions be used to insert logging events in the database.
+            </summary>
+            <value>
+            <c>true</c> if transactions should be used to insert logging events in
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a value that indicates whether transactions should be used
+            to insert logging events in the database.
+            </para>
+            <para>
+            When set a single transaction will be used to insert the buffered events
+            into the database. Otherwise each event will be inserted without using
+            an explicit transaction.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
+            <summary>
+            Should this appender try to reconnect to the database on error.
+            </summary>
+            <value>
+            <c>true</c> if the appender should try to reconnect to the database after an
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
+            i.e. not to try to reconnect.
+            </value>
+            <remarks>
+            <para>
+            The default behaviour is for the appender not to try to reconnect to the
+            database if an error occurs. Subsequent logging events are discarded.
+            </para>
+            <para>
+            To force the appender to attempt to reconnect to the database set this
+            property to <c>true</c>.
+            </para>
+            <note>
+            When the appender attempts to connect to the database there may be a
+            delay of up to the connection timeout specified in the connection string.
+            This delay will block the calling application's thread. 
+            Until the connection can be reestablished this potential delay may occur multiple times.
+            </note>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Data.IDbConnection"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">
+            <summary>
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            This class provides the basic database parameter properties
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
+            </para>
+            <para>This type can be subclassed to provide database specific
+            functionality. The two methods that are called externally are
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.
+            </summary>
+            <remarks>
+            Default constructor for the AdoNetAppenderParameter class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">
+            <summary>
+            Prepare the specified database command object.
+            </summary>
+            <param name="command">The command to prepare.</param>
+            <remarks>
+            <para>
+            Prepares the database command object by adding
+            this parameter to its collection of parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the logging event and set the parameter value in the command.
+            </summary>
+            <param name="command">The command containing the parameter.</param>
+            <param name="loggingEvent">The event to be rendered.</param>
+            <remarks>
+            <para>
+            Renders the logging event using this parameters layout
+            object. Sets the value of the parameter on the command object.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">
+            <summary>
+            The name of this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">
+            <summary>
+            The database type for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">
+            <summary>
+            Flag to infer type rather than use the DbType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">
+            <summary>
+            The precision for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">
+            <summary>
+            The scale for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">
+            <summary>
+            The size for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">
+            <summary>
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the
+            logging event into an object for this parameter.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">
+            <summary>
+            Gets or sets the name of this parameter.
+            </summary>
+            <value>
+            The name of this parameter.
+            </value>
+            <remarks>
+            <para>
+            The name of this parameter. The parameter name
+            must match up to a named parameter to the SQL stored procedure
+            or prepared statement.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">
+            <summary>
+            Gets or sets the database type for this parameter.
+            </summary>
+            <value>
+            The database type for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The database type for this parameter. This property should
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the type from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">
+            <summary>
+            Gets or sets the precision for this parameter.
+            </summary>
+            <value>
+            The precision for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum number of digits used to represent the Value.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the precision from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">
+            <summary>
+            Gets or sets the scale for this parameter.
+            </summary>
+            <value>
+            The scale for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The number of decimal places to which Value is resolved.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the scale from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">
+            <summary>
+            Gets or sets the size for this parameter.
+            </summary>
+            <value>
+            The size for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum size, in bytes, of the data within the column.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the size from the value.
+            </para>
+            <para>
+            For BLOB data types like VARCHAR(max) it may be impossible to infer the value automatically, use -1 as the size in this case.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to 
+            render the logging event into an object for this 
+            parameter.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the
+            logging event into an object for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this
+            parameter.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>
+            for use in the property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">
+            <summary>
+            Appends logging events to the terminal using ANSI color escape sequences.
+            </summary>
+            <remarks>
+            <para>
+            AnsiColorTerminalAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific level of message to be set.
+            </para>
+            <note>
+            This appender expects the terminal to understand the VT100 control set 
+            in order to interpret the color codes. If the terminal or console does not
+            understand the control codes the behavior is not defined.
+            </note>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            <para>
+            When configuring the ANSI colored terminal appender, a mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red"/>
+                <attributes value="Bright,Underscore"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            </list>
+            These color values cannot be combined together to make new colors.
+            </para>
+            <para>
+            The attributes can be any combination of the following:
+            <list type="bullet">
+            <item><term>Bright</term><description>foreground is brighter</description></item>
+            <item><term>Dim</term><description>foreground is dimmer</description></item>
+            <item><term>Underscore</term><description>message is underlined</description></item>
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>
+            <item><term>Hidden</term><description>output is hidden</description></item>
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>
+            </list>
+            While any of these attributes may be combined together not all combinations
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes
+            no sense.
+            </para>
+            </remarks>
+            <author>Patrick Wagstrom</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">
+            <summary>
+            Ansi code to reset terminal
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colours
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">
+            <summary>
+            The enum of possible display attributes
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the ANSI color attributes.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">
+            <summary>
+            text is bright
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">
+            <summary>
+            text is dim
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">
+            <summary>
+            text is underlined
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">
+            <summary>
+            text is blinking
+            </summary>
+            <remarks>
+            Not all terminals support this attribute
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">
+            <summary>
+            text and background colors are reversed
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">
+            <summary>
+            text is hidden
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">
+            <summary>
+            text is displayed with a strikethrough
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Light">
+            <summary>
+            text color is light
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">
+            <summary>
+            The enum of possible foreground or background color values for 
+            use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The output can be in one for the following ANSI colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">
+            <summary>
+            color is black
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">
+            <summary>
+            color is magenta
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMappingEntry">
+            <summary>
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract base class for types that are stored in the
+            <see cref="T:log4net.Util.LevelMapping"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">
+            <summary>
+            Default protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Default protected constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
+            <summary>
+            Initialize any options defined on this entry
+            </summary>
+            <remarks>
+            <para>
+            Should be overridden by any classes that need to initialise based on their options
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LevelMappingEntry.Level">
+            <summary>
+            The level that is the key for this mapping 
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping 
+            </value>
+            <remarks>
+            <para>
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
+            mapping subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together
+            and append the attributes.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">
+            <summary>
+            The color attributes for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The color attributes for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            An <c>AppenderCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">
+            <summary>
+            An empty readonly static AppenderCollection
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <c>AppenderCollection</c>.
+            </summary>
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">
+            <summary>
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clear">
+            <summary>
+            Removes all elements from the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>
+            in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">
+            <summary>
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">
+            <summary>
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">
+            <summary>
+            Return the collection elements as an array
+            </summary>
+            <returns>the array</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            	<para><paramref name="index"/> is less than zero</para>
+            	<para>-or-</para>
+            	<para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Appender.AspNetTraceAppender">
+            <summary>
+            <para>
+            Appends log events to the ASP.NET <see cref="T:System.Web.TraceContext"/> system.
+            </para>
+            </summary>
+            <remarks>
+            <para>
+            Diagnostic information and tracing messages that you specify are appended to the output 
+            of the page that is sent to the requesting browser. Optionally, you can view this information
+            from a separate trace viewer (Trace.axd) that displays trace information for every page in a 
+            given application.
+            </para>
+            <para>
+            Trace statements are processed and displayed only when tracing is enabled. You can control 
+            whether tracing is displayed to a page, to the trace viewer, or both.
+            </para>
+            <para>
+            The logging event is passed to the <see cref="M:TraceContext.Write(string)"/> or 
+            <see cref="M:TraceContext.Warn(string)"/> method depending on the level of the logging event.
+            The event's logger name is the default value for the category parameter of the Write/Warn method. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AspNetTraceAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the ASP.NET trace
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the ASP.NET trace
+            <c>HttpContext.Current.Trace</c> 
+            (<see cref="T:System.Web.TraceContext"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AspNetTraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.BufferingForwardingAppender">
+            <summary>
+            Buffers events and then forwards them to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The events are buffered in this appender until conditions are
+            met to allow the appender to deliver the events to the attached 
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the
+            conditions that cause the buffer to be sent.
+            </para>
+            <para>The forwarding appender can be used to specify different 
+            thresholds and filters for the same appender at different locations 
+            within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Core.IAppenderAttachable">
+            <summary>
+            Interface for attaching appenders to objects.
+            </summary>
+            <remarks>
+            <para>
+            Interface for attaching, removing and retrieving appenders.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="appender">The appender to add.</param>
+            <remarks>
+            <para>
+            Add the specified appender. The implementation may
+            choose to allow or deny duplicate appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Returns an attached appender with the <paramref name="name"/> specified.
+            If no appender with the specified name is found <c>null</c> will be
+            returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <value>
+            A collection of attached appenders.
+            </value>
+            <remarks>
+            <para>
+            Gets a collection of attached appenders.
+            If there are no attached appenders the
+            implementation should return an empty 
+            collection rather than <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            Forwards the events to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this buffering appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes directly to the application's attached console
+            not to the <c>System.Console.Out</c> or <c>System.Console.Error</c> <c>TextWriter</c>.
+            The <c>System.Console.Out</c> and <c>System.Console.Error</c> streams can be
+            programmatically redirected (for example NUnit does this to capture program output).
+            This appender will ignore these redirections because it needs to use Win32
+            API calls to colorize the output. To respect these redirections the <see cref="T:log4net.Appender.ConsoleAppender"/>
+            must be used.
+            </para>
+            <para>
+            When configuring the colored console appender, mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red, HighIntensity"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            combination of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            <item><term>HighIntensity</term><description></description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.AddMapping(log4net.Appender.ColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_consoleOutputWriter">
+            <summary>
+            The console output stream writer to write to
+            </summary>
+            <remarks>
+            <para>
+            This writer is not thread safe.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.Colors">
+            <summary>
+            The enum of possible color values for use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.ColoredConsoleAppender"/>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Purple">
+            <summary>
+            color is purple
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.HighIntensity">
+            <summary>
+            color is intensified
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> together.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> suitable for 
+            setting the console color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.DebugAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the
+            debug system.
+            </para>
+            <para>
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(string,string)"/>
+            method. The event's logger name is passed as the value for the category name to the Write method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>
+            is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_category">
+            <summary>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.Category">
+            <summary>
+            Formats the category parameter sent to the Debug method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender">
+            <summary>
+            Writes events to the system event log.
+            </summary>
+            <remarks>
+            <para>
+            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.
+            See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog
+            </para>
+            <para>
+            The <c>EventID</c> of the event log entry can be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            The <c>Category</c> of the event log entry can be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            <para>
+            When configuring the EventLogAppender a mapping can be
+            specified to map a logging level to an event log entry type. For example:
+            </para>
+            <code lang="XML">
+            &lt;mapping&gt;
+            	&lt;level value="ERROR" /&gt;
+            	&lt;eventLogEntryType value="Error" /&gt;
+            &lt;/mapping&gt;
+            &lt;mapping&gt;
+            	&lt;level value="DEBUG" /&gt;
+            	&lt;eventLogEntryType value="Information" /&gt;
+            &lt;/mapping&gt;
+            </code>
+            <para>
+            The Level is the standard log4net logging level and eventLogEntryType can be any value
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:
+            <list type="bullet">
+            <item><term>Error</term><description>an error event</description></item>
+            <item><term>Warning</term><description>a warning event</description></item>
+            <item><term>Information</term><description>an informational event</description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Thomas Voss</author>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.
+            </summary>
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">
+            <summary>
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.
+            Each mapping defines the event log entry type for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">
+            <summary>
+            Create an event log source
+            </summary>
+            <remarks>
+            Uses different API calls under NET_2_0
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Writes the event to the system event log using the 
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>
+            
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            set then this integer will be used as the event log event id.</para>
+            
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">
+            <summary>
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/>
+            </summary>
+            <param name="level">the Level to convert to an EventLogEntryType</param>
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/></returns>
+            <remarks>
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
+            values to use in logging levels than there are in the 
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is
+            a loss of information during the conversion.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">
+            <summary>
+            The log name is the section in the event logs where the messages
+            are stored.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
+            <summary>
+            Name of the application to use when logging.  This appears in the
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
+            <summary>
+            The name of the machine which holds the event log. This is
+            currently only allowed to be '.' i.e. the current machine.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to EventLogEntryType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_eventId">
+            <summary>
+            The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_category">
+            <summary>
+            The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.declaringType">
+            <summary>
+            The fully qualified type of the EventLogAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_DEFAULT">
+            <summary>
+            The maximum size supported by default.
+            </summary>
+            <remarks>
+            http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx
+            The 32766 documented max size is two bytes shy of 32K (I'm assuming 32766 
+            may leave space for a two byte null terminator of #0#0). The 32766 max 
+            length is what the .NET 4.0 source code checks for, but this is WRONG! 
+            Strings with a length > 31839 on Windows Vista or higher can CORRUPT 
+            the event log! See: System.Diagnostics.EventLogInternal.InternalWriteEvent() 
+            for the use of the 32766 max size.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_VISTA_OR_NEWER">
+            <summary>
+            The maximum size supported by a windows operating system that is vista
+            or newer.
+            </summary>
+            <remarks>
+            See ReportEvent API:
+            	http://msdn.microsoft.com/en-us/library/aa363679(VS.85).aspx
+            ReportEvent's lpStrings parameter:
+            "A pointer to a buffer containing an array of 
+            null-terminated strings that are merged into the message before Event Viewer 
+            displays the string to the user. This parameter must be a valid pointer 
+            (or NULL), even if wNumStrings is zero. Each string is limited to 31,839 characters."
+            
+            Going beyond the size of 31839 will (at some point) corrupt the event log on Windows
+            Vista or higher! It may succeed for a while...but you will eventually run into the
+            error: "System.ComponentModel.Win32Exception : A device attached to the system is
+            not functioning", and the event log will then be corrupt (I was able to corrupt 
+            an event log using a length of 31877 on Windows 7).
+            
+            The max size for Windows Vista or higher is documented here:
+            	http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx.
+            Going over this size may succeed a few times but the buffer will overrun and 
+            eventually corrupt the log (based on testing).
+            
+            The maxEventMsgSize size is based on the max buffer size of the lpStrings parameter of the ReportEvent API.
+            The documented max size for EventLog.WriteEntry for Windows Vista and higher is 31839, but I'm leaving room for a
+            terminator of #0#0, as we cannot see the source of ReportEvent (though we could use an API monitor to examine the
+            buffer, given enough time).
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE">
+            <summary>
+            The maximum size that the operating system supports for
+            a event log message.
+            </summary>
+            <remarks>
+            Used to determine the maximum string length that can be written
+            to the operating system event log and eventually truncate a string
+            that exceeds the limits.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetMaxEventLogMessageSize">
+            <summary>
+            This method determines the maximum event log message size allowed for
+            the current environment.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.LogName">
+            <summary>
+            The name of the log where messages will be stored.
+            </summary>
+            <value>
+            The string name of the log where messages will be stored.
+            </value>
+            <remarks>
+            <para>This is the name of the log as it appears in the Event Viewer
+            tree. The default value is to log into the <c>Application</c>
+            log, this is where most applications write their events. However
+            if you need a separate log for your application (or applications)
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
+            <para>This should not be used to distinguish your event log messages
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
+            property should be used to distinguish events. This property should be 
+            used to group together events into a single log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
+            <summary>
+            Property used to set the Application name.  This appears in the
+            event logs when logging.
+            </summary>
+            <value>
+            The string used to distinguish events from different sources.
+            </value>
+            <remarks>
+            Sets the event log source property.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">
+            <summary>
+            This property is used to return the name of the computer to use
+            when accessing the event logs.  Currently, this is the current
+            computer, denoted by a dot "."
+            </summary>
+            <value>
+            The string name of the machine holding the event log that 
+            will be logged into.
+            </value>
+            <remarks>
+            This property cannot be changed. It is currently set to '.'
+            i.e. the local machine. This may be changed in future.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </value>
+            <remarks>
+            <para>
+            The system security context used to write to the EventLog.
+            </para>
+            <para>
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.EventId">
+            <summary>
+            Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>EventID</c> of the event log entry will normally be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Category">
+            <summary>
+            Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Category</c> of the event log entry will normally be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and its event log entry type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">
+            <summary>
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender">
+            <summary>
+            Appends logging events to a file.
+            </summary>
+            <remarks>
+            <para>
+            Logging events are sent to the file specified by
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.
+            </para>
+            <para>
+            The file can be opened in either append or overwrite mode 
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.
+            If the file path is relative it is taken as relative from 
+            the application base directory. The file encoding can be
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.
+            </para>
+            <para>
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            values will be written each time the file is opened and closed
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>
+            then the file may contain multiple copies of the header and footer.
+            </para>
+            <para>
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> 
+            is to obtain an exclusive write lock on the file until this appender is closed.
+            The alternative models only hold a
+            write lock while the appender is writing a logging event (<see cref="T:log4net.Appender.FileAppender.MinimalLock"/>)
+            or synchronize by using a named system wide Mutex (<see cref="T:log4net.Appender.FileAppender.InterProcessLock"/>).
+            </para>
+            <para>
+            All locking strategies have issues and you should seriously consider using a different strategy that
+            avoids having multiple processes logging to the same file.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Rodrigo B. de Oliveira</author>
+            <author>Douglas de la Torre</author>
+            <author>Niall Daley</author>
+        </member>
+        <member name="T:log4net.Appender.TextWriterAppender">
+            <summary>
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This appender may be used stand alone if initialized with an appropriate
+            writer, however it is typically used as a base class for an appender that
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized 
+            with the specified <see cref="T:System.IO.Stream"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender</param>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
+            <remarks>
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
+            <summary>
+            This method determines if there is a sense in attempting to append.
+            </summary>
+            <remarks>
+            <para>
+            This method checks if an output target has been set and if a
+            layout has been set. 
+            </para>
+            </remarks>
+            <returns><c>false</c> if any of the preconditions fail.</returns>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method writes all the bulk logged events to the output writer
+            before flushing the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+            <remarks>
+            Closed appenders cannot be reused.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
+            <summary>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">
+            <summary>
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> 
+            and other variables.
+            </summary>
+            <remarks>
+            <para>
+            Subclasses can override this method for an alternate closing behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
+            <summary>
+            Called to allow a subclass to lazily initialize the writer
+            </summary>
+            <remarks>
+            <para>
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
+            attempt to initialize the writer multiple times.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
+            <summary>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> 
+            or output stream will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logging events are not actually persisted if and when the application 
+            crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.declaringType">
+            <summary>
+            The fully qualified type of the TextWriterAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
+            <summary>
+            Gets or set whether the appender will flush at the end 
+            of each append operation.
+            </summary>
+            <value>
+            <para>
+            The default behavior is to flush at the end of each 
+            append operation.
+            </para>
+            <para>
+            If this option is set to <c>false</c>, then the underlying 
+            stream can defer persisting the logging event to a later 
+            time.
+            </para>
+            </value>
+            <remarks>
+            Avoiding the flush operation at the end of each append results in
+            a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">
+            <summary>
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
+            </summary>
+            <remarks>
+            <para>
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
+            </para>
+            <para>
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender 
+            instance is closed.
+            </para>
+            <para>
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
+            <summary>
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying 
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </value>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
+            </value>
+            <remarks>
+            <para>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
+            <summary>
+            Construct a new appender using the layout, file and append mode.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <param name="append">flag to indicate if the file should be appended to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
+            <summary>
+            Construct a new appender using the layout and file specified.
+            The file will be appended to.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
+            <summary>
+            Activate the options on the file appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This will cause the file to be opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Reset">
+            <summary>
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.
+            </summary>
+            <remarks>
+            <para>
+            Resets the filename and the file stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">
+            <summary>
+            Called to initialize the file writer
+            </summary>
+            <remarks>
+            <para>
+            Will be called for each logged message until the file is
+            successfully opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Acquires the output file locks once before writing all the events to
+            the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseFile">
+            <summary>
+            Closes the previously opened file.
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then
+            closes the file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            If there was already an opened file, then the previous file
+            is closed first.
+            </para>
+            <para>
+            This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">
+            <summary>
+            Sets the quiet writer used for file output
+            </summary>
+            <param name="fileStream">the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This implementation of <see cref="M:SetQWForFiles(Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>
+            over the <paramref name="fileStream"/> and passes it to the 
+            <see cref="M:SetQWForFiles(TextWriter)"/> method.
+            </para>
+            <para>
+            This method can be overridden by sub classes that want to wrap the
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <param name="writer">the writer over the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This method can be overridden by sub classes that want to
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
+            <summary>
+            Flag to indicate if we should append to the file
+            or overwrite the file. The default is to append.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_fileName">
+            <summary>
+            The name of the log file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_encoding">
+            <summary>
+            The encoding to use for the file stream.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_stream">
+            <summary>
+            The stream to log to. Has added locking semantics
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">
+            <summary>
+            The locking model to use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.declaringType">
+            <summary>
+            The fully qualified type of the FileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.File">
+            <summary>
+            Gets or sets the path to the file that logging will be written to.
+            </summary>
+            <value>
+            The path to the file that logging will be written to.
+            </value>
+            <remarks>
+            <para>
+            If the path is relative it is taken as relative from 
+            the application base directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">
+            <summary>
+            Gets or sets a flag that indicates whether the file should be
+            appended to or overwritten.
+            </summary>
+            <value>
+            Indicates whether the file should be appended to or overwritten.
+            </value>
+            <remarks>
+            <para>
+            If the value is set to false then the file will be overwritten, if 
+            it is set to true then the file will be appended to.
+            </para>
+            The default value is true.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>
+            which is the encoding for the system's current ANSI code page.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModel">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </para>
+            <para>
+            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"/> .
+            The first locks the file from the start of logging to the end, the 
+            second locks only for the minimal amount of time when logging each message
+            and the last synchronizes processes using a named system wide Mutex.
+            </para>
+            <para>
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingStream">
+            <summary>
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> 
+            to manage access to an underlying resource.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
+            <summary>
+            True asynchronous writes are not supported, the implementation forces a synchronous write.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LogException">
+            <summary>
+            Exception base type for log4net.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with
+            the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">
+            <summary>
+            Locking model base class
+            </summary>
+            <remarks>
+            <para>
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the output file
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CreateStream(System.String,System.Boolean,System.IO.FileShare)">
+            <summary>
+            Helper method that creates a FileStream under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            <para>
+            Typically called during OpenFile or AcquireLock. 
+            </para>
+            <para>
+            If the directory portion of the <paramref name="filename"/> does not exist, it is created
+            via Directory.CreateDirecctory.
+            </para>
+            </remarks>
+            <param name="filename"></param>
+            <param name="append"></param>
+            <param name="fileShare"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseStream(System.IO.Stream)">
+            <summary>
+            Helper method to close <paramref name="stream"/> under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            Does not set <paramref name="stream"/> to null.
+            </remarks>
+            <param name="stream"></param>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </summary>
+            <value>
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </value>
+            <remarks>
+            <para>
+            The file appender this locking model is attached to and working on
+            behalf of.
+            </para>
+            <para>
+            The file appender is used to locate the security context and the error handler to use.
+            </para>
+            <para>
+            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
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">
+            <summary>
+            Hold an exclusive lock on the output file
+            </summary>
+            <remarks>
+            <para>
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. 
+            Maintains an exclusive lock on the file during this time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Does nothing. The lock will be released when the file is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">
+            <summary>
+            Acquires the file lock for each write
+            </summary>
+            <remarks>
+            <para>
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, 
+            thus holding the lock for the minimal amount of time. This method of locking
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows 
+            other processes to move/delete the log file whilst logging continues.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Prepares to open the file when the first message is logged.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.InterProcessLock">
+            <summary>
+            Provides cross-process file locking.
+            </summary>
+            <author>Ron Grabowski</author>
+            <author>Steve Wranovsky</author>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/>,
+            -<see cref="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock">
+            <summary>
+            Releases the lock and allows others to acquire a lock.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ForwardingAppender">
+            <summary>
+            This appender forwards logging events to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The forwarding appender can be used to specify different thresholds
+            and filters for the same appender at different locations within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Forward the logging event to the attached appenders 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Forward the logging events to the attached appenders 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging events to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender">
+            <summary>
+            Logs events to a local syslog service.
+            </summary>
+            <remarks>
+            <note>
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.
+            If these functions are not available on the local system then this appender will not work!
+            </note>
+            <para>
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and 
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.
+            </para>
+            <para>
+            This appender talks to a local syslog service. If you need to log to a remote syslog
+            daemon and you cannot configure your local syslog service to do this you may be
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write 
+            to a local syslog service.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">
+            <summary>
+            Close the syslog when the appender is closed
+            </summary>
+            <remarks>
+            <para>
+            Close the syslog when the appender is closed
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">
+            <summary>
+            Marshaled handle to the identity string. We have to hold on to the
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the
+            pointer to the ident and dereference it for each log message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">
+            <summary>
+            Open connection to system logger.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">
+            <summary>
+            Generate a log message.
+            </summary>
+            <remarks>
+            <para>
+            The libc syslog method takes a format string and a variable argument list similar
+            to the classic printf function. As this type of vararg list is not supported
+            by C# we need to specify the arguments explicitly. Here we have specified the
+            format string with a single message argument. The caller must set the format 
+            string to <c>"%s"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">
+            <summary>
+            Close descriptor used to write to system logger.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The log4net Level maps to a syslog severity using the
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facility defines which subsystem the logging comes from.
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender">
+            <summary>
+            Appends colorful logging events to the console, using the .NET 2
+            built-in capabilities.
+            </summary>
+            <remarks>
+            <para>
+            ManagedColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            When configuring the colored console appender, mappings should be
+            specified to map logging levels to colors. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="DarkRed"/>
+            	<backColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="WARN"/>
+            	<foreColor value="Yellow"/>
+            </mapping>
+            <mapping>
+            	<level value="INFO"/>
+            	<foreColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<foreColor value="Blue"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level while
+            ForeColor and BackColor are the values of <see cref="T:System.ConsoleColor"/>
+            enumeration.
+            </para>
+            <para>
+            Based on the ColoredConsoleAppender
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+            <author>Pavlos Touboulidis</author>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.AddMapping(log4net.Appender.ManagedColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.MemoryAppender">
+            <summary>
+            Stores logging events in an array.
+            </summary>
+            <remarks>
+            <para>
+            The memory appender stores all the logging events
+            that are appended in an in-memory array.
+            </para>
+            <para>
+            Use the <see cref="M:PopAllEvents()"/> method to get
+            and clear the current list of events that have been appended.
+            </para>
+            <para>
+            Use the <see cref="M:GetEvents()"/> method to get the current
+            list of events that have been appended.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            <para>
+            Use the <see cref="M:Clear()"/> method to clear the
+            current list of events.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            </remarks>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">
+            <summary>
+            Gets the events that have been logged.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Clear">
+            <summary>
+            Clear the list of events
+            </summary>
+            <remarks>
+            Clear the list of events
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.PopAllEvents">
+            <summary>
+            Gets the events that have been logged and clears the list of events.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged and clears the list of events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
+            <summary>
+            The list of events that have been appended.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating whether only part of the logging event 
+            data should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the event 
+            data to be fixed and stored in the appender, hereby improving performance. 
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(bool)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.Fix">
+            <summary>
+            Gets or sets the fields that will be fixed in the event
+            </summary>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.NetSendAppender">
+            <summary>
+            Logs entries by sending network messages using the 
+            <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> native function.
+            </summary>
+            <remarks>
+            <para>
+            You can send messages only to names that are active 
+            on the network. If you send the message to a user name, 
+            that user must be logged on and running the Messenger 
+            service to receive the message.
+            </para>
+            <para>
+            The receiver will get a top most window displaying the 
+            messages one at a time, therefore this appender should 
+            not be used to deliver a high volume of messages.
+            </para>
+            <para>
+            The following table lists some possible uses for this appender :
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Action</term>
+                    <description>Property Value(s)</description>
+                </listheader>
+                <item>
+                    <term>Send a message to a user account on the local machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a user account on a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the remote machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a domain user account</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of a domain controller | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to all the names in a workgroup or domain</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;workgroup name | domain name&gt;*
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message from the local machine to a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;name of the remote machine&gt;
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            <b>Note :</b> security restrictions apply for sending 
+            network messages, see <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> 
+            for more information.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            An example configuration section to log information 
+            using this appender from the local machine, named 
+            LOCAL_PC, to machine OPERATOR_PC :
+            </para>
+            <code lang="XML" escaped="true">
+            <appender name="NetSendAppender_Operator" type="log4net.Appender.NetSendAppender">
+                <server value="LOCAL_PC"/>
+                <recipient value="OPERATOR_PC"/>
+                <layout type="log4net.Layout.PatternLayout" value="%-5p %c [%x] - %m%n"/>
+            </appender>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_server">
+            <summary>
+            The DNS or NetBIOS name of the server on which the function is to execute.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_sender">
+            <summary>
+            The sender of the network message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_recipient">
+            <summary>
+            The message alias to which the message should be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.#ctor">
+            <summary>
+            Initializes the appender.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was not specified.</exception>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using a network message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)">
+            <summary>
+            Sends a buffer of information to a registered message alias.
+            </summary>
+            <param name="serverName">The DNS or NetBIOS name of the server on which the function is to execute.</param>
+            <param name="msgName">The message alias to which the message buffer should be sent</param>
+            <param name="fromName">The originator of the message.</param>
+            <param name="buffer">The message text.</param>
+            <param name="bufferSize">The length, in bytes, of the message text.</param>
+            <remarks>
+            <para>
+            The following restrictions apply for sending network messages:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Platform</term>
+                    <description>Requirements</description>
+                </listheader>
+                <item>
+                    <term>Windows NT</term>
+                    <description>
+                        <para>
+                        No special group membership is required to send a network message.
+                        </para>
+                        <para>
+                        Admin, Accounts, Print, or Server Operator group membership is required to 
+                        successfully send a network message on a remote server.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Windows 2000 or later</term>
+                    <description>
+                        <para>
+                        If you send a message on a domain controller that is running Active Directory, 
+                        access is allowed or denied based on the access control list (ACL) for the securable 
+                        object. The default ACL permits only Domain Admins and Account Operators to send a network message. 
+                        </para>
+                        <para>
+                        On a member server or workstation, only Administrators and Server Operators can send a network message. 
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            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>.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is zero.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Sender">
+            <summary>
+            Gets or sets the sender of the message.
+            </summary>
+            <value>
+            The sender of the message.
+            </value>
+            <remarks>
+            If this property is not specified, the message is sent from the local computer.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Recipient">
+            <summary>
+            Gets or sets the message alias to which the message should be sent.
+            </summary>
+            <value>
+            The recipient of the message.
+            </value>
+            <remarks>
+            This property should always be specified in order to send a message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Server">
+            <summary>
+            Gets or sets the DNS or NetBIOS name of the remote server on which the function is to execute.
+            </summary>
+            <value>
+            DNS or NetBIOS name of the remote server on which the function is to execute.
+            </value>
+            <remarks>
+            <para>
+            For Windows NT 4.0 and earlier, the string should begin with \\.
+            </para>
+            <para>
+            If this property is not specified, the local computer is used. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.OutputDebugStringAppender">
+            <summary>
+            Appends log events to the OutputDebugString system.
+            </summary>
+            <remarks>
+            <para>
+            OutputDebugStringAppender appends log events to the
+            OutputDebugString system.
+            </para>
+            <para>
+            The string is passed to the native <c>OutputDebugString</c> 
+            function.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.OutputDebugStringAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the output debug string API
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the output debug string API
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">
+            <summary>
+            Stub for OutputDebugString native method
+            </summary>
+            <param name="message">the string to output</param>
+            <remarks>
+            <para>
+            Stub for OutputDebugString native method
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.OutputDebugStringAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender">
+            <summary>
+            Logs events to a remote syslog daemon.
+            </summary>
+            <remarks>
+            <para>
+            The BSD syslog protocol is used to remotely log to
+            a syslog daemon. The syslogd listens for for messages
+            on UDP port 514.
+            </para>
+            <para>
+            The syslog UDP protocol is not authenticated. Most syslog daemons
+            do not accept remote log messages because of the security implications.
+            You may be able to use the LocalSyslogAppender to talk to a local
+            syslog service.
+            </para>
+            <para>
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.
+            This appender generates what the RFC calls an "Original Device Message",
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation
+            this format of message will be accepted by all current syslog daemon
+            implementations. The daemon will attach the current time and the source
+            hostname or IP address to any messages received.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Appender.UdpAppender">
+             <summary>
+             Sends logging events as connectionless UDP datagrams to a remote host or a 
+             multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.
+             </summary>
+             <remarks>
+             <para>
+             UDP guarantees neither that messages arrive, nor that they arrive in the correct order.
+             </para>
+             <para>
+             To view the logging results, a custom application can be developed that listens for logging 
+             events.
+             </para>
+             <para>
+             When decoding events send via this appender remember to use the same encoding
+             to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>
+             property to specify the encoding to use.
+             </para>
+             </remarks>
+             <example>
+             This example shows how to log receive logging events that are sent 
+             on IP address 244.0.0.1 and port 8080 to the console. The event is 
+             encoded in the packet as a unicode string and it is decoded as such. 
+             <code lang="C#">
+             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+             UdpClient udpClient;
+             byte[] buffer;
+             string loggingEvent;
+             
+             try 
+             {
+                 udpClient = new UdpClient(8080);
+                 
+                 while(true) 
+                 {
+                     buffer = udpClient.Receive(ref remoteEndPoint);
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
+                     Console.WriteLine(loggingEvent);
+                 }
+             } 
+             catch(Exception e) 
+             {
+                 Console.WriteLine(e.ToString());
+             }
+             </code>
+             <code lang="Visual Basic">
+             Dim remoteEndPoint as IPEndPoint
+             Dim udpClient as UdpClient
+             Dim buffer as Byte()
+             Dim loggingEvent as String
+             
+             Try 
+                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
+                 udpClient = new UdpClient(8080)
+            
+                 While True
+                     buffer = udpClient.Receive(ByRef remoteEndPoint)
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
+                     Console.WriteLine(loggingEvent)
+                 Wend
+             Catch e As Exception
+                 Console.WriteLine(e.ToString())
+             End Try
+             </code>
+             <para>
+             An example configuration section to log information using this appender to the 
+             IP 224.0.0.1 on port 8080:
+             </para>
+             <code lang="XML" escaped="true">
+             <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
+                 <remoteAddress value="224.0.0.1"/>
+                 <remotePort value="8080"/>
+                 <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>
+             </appender>
+             </code>
+             </example>
+             <author>Gert Driesen</author>
+             <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or 
+            an invalid remote or local TCP port number was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>
+            <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>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using an UDP datagram.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.OnClose">
+            <summary>
+            Closes the UDP connection and releases all resources associated with 
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed 
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">
+            <summary>
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.
+            </summary>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the 
+            port number from which you intend to communicate.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">
+            <summary>
+            The IP address of the remote host or multicast group to which 
+            the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">
+            <summary>
+            The TCP port number of the remote host or multicast group to 
+            which the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">
+            <summary>
+            The cached remote endpoint to which the logging events will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">
+            <summary>
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_client">
+            <summary>
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the 
+            logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">
+            <summary>
+            The encoding to use for the packet.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">
+            <summary>
+            Gets or sets the IP address of the remote host or multicast group to which
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            The IP address of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            <para>
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so
+            it is possible to use multicasts in an Internet scenario as long as your network provider 
+            supports multicasting.
+            </para>
+            <para>
+            Hosts that want to receive particular multicast messages must register their interest by joining
+            the multicast group.  Multicast messages are not sent to networks where no host has joined
+            the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
+            them from normal host addresses, allowing nodes to easily detect if a message is of interest.
+            </para>
+            <para>
+            Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>IP Address</term>
+                    <description>Description</description>
+                </listheader>
+                <item>
+                    <term>224.0.0.1</term>
+                    <description>
+                        <para>
+                        Sends a message to all system on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.2</term>
+                    <description>
+                        <para>
+                        Sends a message to all routers on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.12</term>
+                    <description>
+                        <para>
+                        The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            A complete list of actually reserved multicast addresses and their owners in the ranges
+            defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
+            </para>
+            <para>
+            The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
+            addresses.  These addresses can be reused with other local groups.  Routers are typically 
+            configured with filters to prevent multicast traffic in this range from flowing outside
+            of the local network.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemotePort">
+            <summary>
+            Gets or sets the TCP port number of the remote host or multicast group to which 
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will send messages to this TCP port number
+            on the remote host or multicast group.
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.LocalPort">
+            <summary>
+            Gets or sets the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </value>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will bind to this port for sending messages.
+            </para>
+            <para>
+            Setting the value to 0 (the default) will cause the udp client not to bind to
+            a local port.
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Client">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.UdpAppender"/> creates a <see cref="T:System.Net.Sockets.UdpClient"/> to send logging events 
+            over a network.  Classes deriving from <see cref="T:log4net.Appender.UdpAppender"/> can use this
+            property to get or set this <see cref="T:System.Net.Sockets.UdpClient"/>.  Use the underlying <see cref="T:System.Net.Sockets.UdpClient"/>
+            returned from <see cref="P:log4net.Appender.UdpAppender.Client"/> if you require access beyond that which 
+            <see cref="T:log4net.Appender.UdpAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteEndPoint">
+            <summary>
+            Gets or sets the cached remote endpoint to which the logging events should be sent.
+            </summary>
+            <value>
+            The cached remote endpoint to which the logging events will be sent.
+            </value>
+            <remarks>
+            The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method will initialize the remote endpoint 
+            with the values of the <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> and <see cref="P:log4net.Appender.UdpAppender.RemotePort"/>
+            properties.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.DefaultSyslogPort">
+            <summary>
+            Syslog port 514
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class is set up to write 
+            to a remote syslog daemon.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.AddMapping(log4net.Appender.RemoteSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity"/> mapping to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to syslog severity mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GeneratePriority(log4net.Appender.RemoteSyslogAppender.SyslogFacility,log4net.Appender.RemoteSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+            <remarks>
+            <para>
+            Generate a syslog priority.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The syslog severities.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facilities
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender">
+            <summary>
+            Delivers logging events to a remote logging sink. 
+            </summary>
+            <remarks>
+            <para>
+            This Appender is designed to deliver events to a remote sink. 
+            That is any object that implements the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface. It delivers the events using .NET remoting. The
+            object to deliver events to is specified by setting the
+            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.</para>
+            <para>
+            The RemotingAppender buffers events before sending them. This allows it to 
+            make more efficient use of the remoting infrastructure.</para>
+            <para>
+            Once the buffer is full the events are still not sent immediately. 
+            They are scheduled to be sent using a pool thread. The effect is that 
+            the send occurs asynchronously. This is very important for a 
+            number of non obvious reasons. The remoting infrastructure will 
+            flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.</para>
+            <para>
+            Because the events are sent asynchronously using pool threads it is possible to close 
+            this appender before all the queued events have been sent.
+            When closing the appender attempts to wait until all the queued events have been sent, but 
+            this will timeout after 30 seconds regardless.</para>
+            <para>
+            If this appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for. If the runtime terminates the threads before
+            the queued events have been sent then they will be lost. To ensure that all events
+            are sent the appender must be closed before the application exits. See 
+            <see cref="M:log4net.Core.LoggerManager.Shutdown"/> for details on how to shutdown
+            log4net programmatically.</para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemotingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            The events are not sent immediately. They are scheduled to be sent
+            using a pool thread. The effect is that the send occurs asynchronously.
+            This is very important for a number of non obvious reasons. The remoting
+            infrastructure will flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.
+            </remarks>
+            <param name="events">The events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.OnClose">
+            <summary>
+            Override base class close.
+            </summary>
+            <remarks>
+            <para>
+            This method waits while there are queued work items. The events are
+            sent asynchronously using <see cref="T:System.Threading.ThreadPool"/> work items. These items
+            will be sent once a thread pool thread is available to send them, therefore
+            it is possible to close the appender before all the queued events have been
+            sent.</para>
+            <para>
+            This method attempts to wait until all the queued events have been sent, but this 
+            method will timeout after 30 seconds regardless.</para>
+            <para>
+            If the appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.BeginAsyncSend">
+            <summary>
+            A work item is being queued into the thread pool
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.EndAsyncSend">
+            <summary>
+            A work item from the thread pool has completed
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBufferCallback(System.Object)">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            This method is designed to be used with the <see cref="T:System.Threading.ThreadPool"/>.
+            This method expects to be passed an array of <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the state param.
+            </remarks>
+            <param name="state">the logging events to send</param>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">
+            <summary>
+            The URL of the remote sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">
+            <summary>
+            The local proxy (.NET remoting) for the remote logging sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_queuedCallbackCount">
+            <summary>
+            The number of queued callbacks currently waiting or executing
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_workQueueEmptyEvent">
+            <summary>
+            Event used to signal when there are no queued work items
+            </summary>
+            <remarks>
+            This event is set when there are no queued work items. In this
+            state it is safe to close the appender.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemotingAppender.Sink">
+            <summary>
+            Gets or sets the URL of the well-known object that will accept 
+            the logging events.
+            </summary>
+            <value>
+            The well-known URL of the remote sink.
+            </value>
+            <remarks>
+            <para>
+            The URL of the remoting sink that will accept logging events.
+            The sink must implement the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink">
+            <summary>
+            Interface used to deliver <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            This interface must be implemented by a remoting sink
+            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used
+            to deliver logging events to the sink.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.IRemoteLoggingSink.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Delivers logging events to the remote sink
+            </summary>
+            <param name="events">Array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers logging events to the remote sink
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender">
+            <summary>
+            Appender that rolls log files based on size or date or both.
+            </summary>
+            <remarks>
+            <para>
+            RollingFileAppender can roll log files based on size or date or both
+            depending on the setting of the <see cref="P:log4net.Appender.RollingFileAppender.RollingStyle"/> property.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Size"/> the log file will be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Date"/> the log file will be rolled
+            once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/> the log file will be
+            rolled once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed, but within a date boundary the file will also be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> the log file will be rolled when
+            the appender is configured. This effectively means that the log file can be
+            rolled once per program execution.
+            </para>
+            <para>
+            A of few additional optional features have been added:
+            <list type="bullet">
+            <item>Attach date pattern for current log file <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/></item>
+            <item>Backup number increments for newer files <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/></item>
+            <item>Infinite number of backups by file size <see cref="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups"/></item>
+            </list>
+            </para>
+            
+            <note>
+            <para>
+            For large or infinite numbers of backup files a <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> 
+            greater than zero is highly recommended, otherwise all the backup files need
+            to be renamed each time a new backup is created.
+            </para>
+            <para>
+            When Date/Time based rolling is used setting <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> 
+            to <see langword="true"/> will reduce the number of file renamings to few or none.
+            </para>
+            </note>
+            
+            <note type="caution">
+            <para>
+            Changing <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> or <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> without clearing
+            the log file directory of backup files will cause unexpected and unwanted side effects.  
+            </para>
+            </note>
+            
+            <para>
+            If Date/Time based rolling is enabled this appender will attempt to roll existing files
+            in the directory without a Date/Time tag based on the last write date of the base log file.
+            The appender only rolls the log file when a message is logged. If Date/Time based rolling 
+            is enabled then the appender will not roll the log file at the Date/Time boundary but
+            at the point when the next message is logged after the boundary has been crossed.
+            </para>
+            
+            <para>
+            The <see cref="T:log4net.Appender.RollingFileAppender"/> extends the <see cref="T:log4net.Appender.FileAppender"/> and
+            has the same behavior when opening the log file.
+            The appender will first try to open the file for writing when <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            When rolling a backup file necessitates deleting an older backup file the
+            file to be deleted is moved to a temporary name before being deleted.
+            </para>
+            
+            <note type="caution">
+            <para>
+            A maximum number of backup files when rolling on date/time boundaries is not supported.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Edward Smit</author>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RollingFileAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Finalize">
+            <summary>
+            Cleans up all resources used by this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.declaringType">
+            <summary>
+            The fully qualified type of the RollingFileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <remarks>
+            This method can be overridden by sub classes.
+            </remarks>
+            <param name="writer">the writer to set</param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write out a logging event.
+            </summary>
+            <param name="loggingEvent">the event to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Write out an array of logging events.
+            </summary>
+            <param name="loggingEvents">the events to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.AdjustFileBeforeAppend">
+            <summary>
+            Performs any required rolling before outputting the next event
+            </summary>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Creates and opens the file for logging.  If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/>
+            is false then the fully qualified name is determined and used.
+            </summary>
+            <param name="fileName">the name of the file to open</param>
+            <param name="append">true to append to existing file</param>
+            <remarks>
+            <para>This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetNextOutputFileName(System.String)">
+            <summary>
+            Get the current output file name
+            </summary>
+            <param name="fileName">the base file name</param>
+            <returns>the output file name</returns>
+            <remarks>
+            The output file name is based on the base fileName specified.
+            If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> is set then the output 
+            file name is the same as the base file passed in. Otherwise
+            the output file depends on the date pattern, on the count
+            direction or both.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DetermineCurSizeRollBackups">
+            <summary>
+            Determines curSizeRollBackups (only within the current roll point)
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">
+            <summary>
+            Generates a wildcard pattern that can be used to find all files
+            that are similar to the base file name.
+            </summary>
+            <param name="baseFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">
+            <summary>
+            Builds a list of filenames for all files matching the base filename plus a file
+            pattern.
+            </summary>
+            <param name="baseFilePath"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">
+            <summary>
+            Initiates a roll over if needed for crossing a date boundary since the last run.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">
+            <summary>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            </summary>
+            <remarks>
+            <para>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            The following is done
+            <list type="bullet">
+            <item>determine curSizeRollBackups (only within the current roll point)</item>
+            <item>initiates a roll over if needed for crossing a date boundary since the last run.</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">
+            <summary>
+            Does the work of bumping the 'current' file counter higher
+            to the highest count when an incremental file name is seen.
+            The highest count is either the first file (when count direction
+            is greater than 0) or the last file (when count direction less than 0).
+            In either case, we want to know the highest count that is present.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="curFileName"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetBackUpIndex(System.String)">
+            <summary>
+            Attempts to extract a number from the end of the file name that indicates
+            the number of the times the file has been rolled over.
+            </summary>
+            <remarks>
+            Certain date pattern extensions like yyyyMMdd will be parsed as valid backup indexes.
+            </remarks>
+            <param name="curFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">
+            <summary>
+            Takes a list of files and a base file name, and looks for 
+            'incremented' versions of the base file.  Bumps the max
+            count up to the highest count seen.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="arrayFiles"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod(System.String)">
+            <summary>
+            Calculates the RollPoint for the datePattern supplied.
+            </summary>
+            <param name="datePattern">the date pattern to calculate the check period for</param>
+            <returns>The RollPoint that is most accurate for the date pattern supplied</returns>
+            <remarks>
+            Essentially the date pattern is examined to determine what the
+            most suitable roll point is. The roll point chosen is the roll point
+            with the smallest period that can be detected using the date pattern
+            supplied. i.e. if the date pattern only outputs the year, month, day 
+            and hour then the smallest roll point that can be detected would be
+            and hourly roll point as minutes could not be detected.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Sets initial conditions including date/time roll over information, first check,
+            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize
+            the current number of backups.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.CombinePath(System.String,System.String)">
+            <summary>
+            
+            </summary>
+            <param name="path1"></param>
+            <param name="path2">.1, .2, .3, etc.</param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime(System.Boolean)">
+            <summary>
+            Rollover the file(s) to date/time tagged file(s).
+            </summary>
+            <param name="fileIsOpen">set to true if the file to be rolled is currently open</param>
+            <remarks>
+            <para>
+            Rollover the file(s) to date/time tagged file(s).
+            Resets curSizeRollBackups. 
+            If fileIsOpen is set then the new file is opened (through SafeOpenFile).
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">
+            <summary>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>.
+            </summary>
+            <param name="fromFile">Name of existing file to roll.</param>
+            <param name="toFile">New name for file.</param>
+            <remarks>
+            <para>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. It
+            also checks for existence of target file and deletes if it does.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.FileExists(System.String)">
+            <summary>
+            Test if a file exists at a specified path
+            </summary>
+            <param name="path">the path to the file</param>
+            <returns>true if the file exists</returns>
+            <remarks>
+            <para>
+            Test if a file exists at a specified path
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">
+            <summary>
+            Deletes the specified file if it exists.
+            </summary>
+            <param name="fileName">The file to delete.</param>
+            <remarks>
+            <para>
+            Delete a file if is exists.
+            The file is first moved to a new filename then deleted.
+            This allows the file to be removed even when it cannot
+            be deleted, but it still can be moved.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">
+            <summary>
+            Implements file roll base on file size.
+            </summary>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. Moreover, <c>File</c> is
+            renamed <c>File.1</c> and closed.
+            </para>
+            <para>
+            A new file is created to receive further log output.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverRenameFiles(System.String)">
+            <summary>
+            Implements file roll.
+            </summary>
+            <param name="baseFileName">the base name to rename</param>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. 
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            <para>
+            This is called by <see cref="M:log4net.Appender.RollingFileAppender.RollOverSize"/> to rename the files.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">
+            <summary>
+            Get the start time of the next window for the current rollpoint
+            </summary>
+            <param name="currentDateTime">the current date</param>
+            <param name="rollPoint">the type of roll point we are working with</param>
+            <returns>the start time for the next roll point an interval after the currentDateTime date</returns>
+            <remarks>
+            <para>
+            Returns the date of the next roll point after the currentDateTime date passed to the method.
+            </para>
+            <para>
+            The basic strategy is to subtract the time parts that are less significant
+            than the rollpoint from the current time. This should roll the time back to
+            the start of the time window for the current rollpoint. Then we add 1 window
+            worth of time and get the start time of the next window for the rollpoint.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">
+            <summary>
+            This object supplies the current date/time.  Allows test code to plug in
+            a method to control this class when testing date/time based rolling. The default
+            implementation uses the underlying value of DateTime.Now.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">
+            <summary>
+            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> 
+            meaning daily rollover.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">
+            <summary>
+            The actual formatted filename that is currently being written to
+            or will be the file transferred to on roll over
+            (based on staticLogFileName).
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">
+            <summary>
+            The timestamp when we shall next recompute the filename.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_now">
+            <summary>
+            Holds date of last roll over
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">
+            <summary>
+            The type of rolling done
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">
+            <summary>
+            The default maximum file size is 10MB
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">
+            <summary>
+            There is zero backup files by default
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">
+            <summary>
+            How many sized based backups have been made so far
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">
+            <summary>
+            The rolling file count direction. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">
+            <summary>
+            The rolling mode used in this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">
+            <summary>
+            Cache flag set if we are rolling by date.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">
+            <summary>
+            Cache flag set if we are rolling by size.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">
+            <summary>
+            Value indicating whether to always log to the same file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_preserveLogFileNameExtension">
+            <summary>
+            Value indicating whether to preserve the file name extension when rolling.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">
+            <summary>
+            FileName provided in configuration.  Used for rolling properly
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_mutexForRolling">
+            <summary>
+            A mutex that is used to lock rolling of files.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DateTimeStrategy">
+            <summary>
+            Gets or sets the strategy for determining the current date and time. The default
+            implementation is to use LocalDateTime which internally calls through to DateTime.Now. 
+            DateTime.UtcNow may be used on frameworks newer than .NET 1.0 by specifying
+            <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </summary>
+            <value>
+            An implementation of the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> interface which returns the current date and time.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> used to return the current date and time.
+            </para>
+            <para>
+            There are two built strategies for determining the current date and time, 
+            <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>
+            and <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </para>
+            <para>
+            The default strategy is <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">
+            <summary>
+            Gets or sets the date pattern to be used for generating file names
+            when rolling over on date.
+            </summary>
+            <value>
+            The date pattern to be used for generating file names when rolling 
+            over on date.
+            </value>
+            <remarks>
+            <para>
+            Takes a string in the same format as expected by 
+            <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.
+            </para>
+            <para>
+            This property determines the rollover schedule when rolling over
+            on date.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">
+            <summary>
+            Gets or sets the maximum number of backup files that are kept before
+            the oldest is erased.
+            </summary>
+            <value>
+            The maximum number of backup files that are kept before the oldest is
+            erased.
+            </value>
+            <remarks>
+            <para>
+            If set to zero, then there will be no backup files and the log file 
+            will be truncated when it reaches <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  
+            </para>
+            <para>
+            If a negative number is supplied then no deletions will be made.  Note 
+            that this could result in very slow performance as a large number of 
+            files are rolled over unless <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> is used.
+            </para>
+            <para>
+            The maximum applies to <b>each</b> time based group of files and 
+            <b>not</b> the total.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size in bytes that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except
+            that it is required for differentiating the setter taking a
+            <see cref="T:System.Int64"/> argument from the setter taking a <see cref="T:System.String"/> 
+            argument.
+            </para>
+            <para>
+            The default maximum file size is 10MB (10*1024*1024).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property allows you to specify the maximum size with the
+            suffixes "KB", "MB" or "GB" so that the size is interpreted being 
+            expressed respectively in kilobytes, megabytes or gigabytes. 
+            </para>
+            <para>
+            For example, the value "10KB" will be interpreted as 10240 bytes.
+            </para>
+            <para>
+            The default maximum file size is 10MB.
+            </para>
+            <para>
+            If you have the option to set the maximum file size programmatically
+            consider using the <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/> property instead as this
+            allows you to set the size in bytes as a <see cref="T:System.Int64"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">
+            <summary>
+            Gets or sets the rolling file count direction. 
+            </summary>
+            <value>
+            The rolling file count direction.
+            </value>
+            <remarks>
+            <para>
+            Indicates if the current file is the lowest numbered file or the
+            highest numbered file.
+            </para>
+            <para>
+            By default newer files have lower numbers (<see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &lt; 0),
+            i.e. log.1 is most recent, log.5 is the 5th backup, etc...
+            </para>
+            <para>
+            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 does the opposite i.e.
+            log.1 is the first backup made, log.5 is the 5th backup made, etc.
+            For infinite backups use <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 to reduce 
+            rollover costs.
+            </para>
+            <para>The default file count direction is -1.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">
+            <summary>
+            Gets or sets the rolling style.
+            </summary>
+            <value>The rolling style.</value>
+            <remarks>
+            <para>
+            The default rolling style is <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/>.
+            </para>
+            <para>
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> this appender's
+            <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is set to <c>false</c>, otherwise
+            the appender would append to a single file rather than rolling
+            the file each time it is opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.PreserveLogFileNameExtension">
+            <summary>
+            Gets or sets a value indicating whether to preserve the file name extension when rolling.
+            </summary>
+            <value>
+            <c>true</c> if the file name extension should be preserved.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is rolled to file.log.yyyy-MM-dd or file.log.curSizeRollBackup.
+            However, under Windows the new file name will loose any program associations as the
+            extension is changed. Optionally file.log can be renamed to file.yyyy-MM-dd.log or
+            file.curSizeRollBackup.log to maintain any program associations.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">
+            <summary>
+            Gets or sets a value indicating whether to always log to
+            the same file.
+            </summary>
+            <value>
+            <c>true</c> if always should be logged to the same file, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is always the current file.  Optionally
+            file.log.yyyy-mm-dd for current formatted datePattern can by the currently
+            logging file (or file.log.curSizeRollBackup or even
+            file.log.yyyy-mm-dd.curSizeRollBackup).
+            </para>
+            <para>
+            This will make time based rollovers with a large number of backups 
+            much faster as the appender it won't have to rename all the backups!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">
+            <summary>
+            Style of rolling to use
+            </summary>
+            <remarks>
+            <para>
+            Style of rolling to use
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Once">
+            <summary>
+            Roll files once per program execution
+            </summary>
+            <remarks>
+            <para>
+            Roll files once per program execution.
+            Well really once each time this appender is
+            configured.
+            </para>
+            <para>
+            Setting this option also sets <c>AppendToFile</c> to
+            <c>false</c> on the <c>RollingFileAppender</c>, otherwise
+            this appender would just be a normal file appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">
+            <summary>
+            Roll files based only on the size of the file
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">
+            <summary>
+            Roll files based only on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">
+            <summary>
+            Roll files based on both the size and date of the file
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">
+            <summary>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </summary>
+            <remarks>
+            <para>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.InvalidRollPoint">
+            <summary>
+            Roll the log not based on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMinute">
+            <summary>
+            Roll the log for each minute
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfHour">
+            <summary>
+            Roll the log for each hour
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HalfDay">
+            <summary>
+            Roll the log twice a day (midday and midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfDay">
+            <summary>
+            Roll the log each day (midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfWeek">
+            <summary>
+            Roll the log each week
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMonth">
+            <summary>
+            Roll the log each month
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.IDateTime">
+            <summary>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            </summary>
+            <remarks>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            Used primarily to allow test classes to plug themselves in so they can
+            supply test date/times.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.IDateTime.Now">
+            <summary>
+            Gets the <i>current</i> time.
+            </summary>
+            <value>The <i>current</i> time.</value>
+            <remarks>
+            <para>
+            Gets the <i>current</i> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.LocalDateTime">
+            <summary>
+            Default implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.LocalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.UniversalDateTime">
+            <summary>
+            Implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time as the coordinated universal time (UTC).
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.UniversalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender">
+            <summary>
+            Send an e-mail when a specific logging event occurs, typically on errors 
+            or fatal errors.
+            </summary>
+            <remarks>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            <note type="caution">
+            Authentication and setting the server Port are only available on the MS .NET 1.1 runtime.
+            For these features to be enabled you need to ensure that you are using a version of
+            the log4net assembly that is built against the MS .NET 1.1 framework and that you are
+            running the your application on the MS .NET 1.1 runtime. On all other platforms only sending
+            unauthenticated messages to a server listening on port 25 (the default) is supported.
+            </note>
+            <para>
+            Authentication is supported by setting the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property to
+            either <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> or <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>.
+            If using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> authentication then the <see cref="P:log4net.Appender.SmtpAppender.Username"/>
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> properties must also be set.
+            </para>
+            <para>
+            To set the SMTP server port use the <see cref="P:log4net.Appender.SmtpAppender.Port"/> property. The default port is 25.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendEmail(System.String)">
+            <summary>
+            Send the email message
+            </summary>
+            <param name="messageBody">the body text to include in the mail</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.MaybeTrimSeparators(System.String)">
+            <summary>
+              trims leading and trailing commas or semicolons
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.To">
+            <summary>
+            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).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Cc">
+            <summary>
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses 
+            that will be carbon copied (use semicolon on .NET 1.1 and comma for later versions).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Bcc">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses
+            that will be blind carbon copied.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of recipient e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SmtpHost">
+            <summary>
+            Gets or sets the name of the SMTP relay mail server to use to send 
+            the e-mail messages.
+            </summary>
+            <value>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </value>
+            <remarks>
+            <para>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.LocationInfo">
+            <summary>
+            Obsolete
+            </summary>
+            <remarks>
+            Use the BufferingAppenderSkeleton Fix methods instead 
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Authentication">
+            <summary>
+            The mode to use to authentication with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            Valid Authentication mode values are: <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>, 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, and <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>. 
+            The default value is <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>. When using 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> you must specify the <see cref="P:log4net.Appender.SmtpAppender.Username"/> 
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> to use to authenticate.
+            When using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/> the Windows credentials for the current
+            thread, if impersonating, or the process will be used to authenticate. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Username">
+            <summary>
+            The username to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the username will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Password">
+            <summary>
+            The password to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the password will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Port">
+            <summary>
+            The port on which the SMTP server is listening
+            </summary>
+            <remarks>
+            <note type="caution">Server Port is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            The port on which the SMTP server is listening. The default
+            port is <c>25</c>. The Port can only be changed when running on
+            the MS .NET 1.1 runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Priority">
+            <summary>
+            Gets or sets the priority of the e-mail message
+            </summary>
+            <value>
+            One of the <see cref="T:System.Net.Mail.MailPriority"/> values.
+            </value>
+            <remarks>
+            <para>
+            Sets the priority of the e-mails generated by this
+            appender. The default priority is <see cref="F:System.Net.Mail.MailPriority.Normal"/>.
+            </para>
+            <para>
+            If you are using this appender to report errors then
+            you may want to set the priority to <see cref="F:System.Net.Mail.MailPriority.High"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.EnableSsl">
+            <summary>
+            Enable or disable use of SSL when sending e-mail message
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.ReplyTo">
+            <summary>
+            Gets or sets the reply-to e-mail address.
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SubjectEncoding">
+            <summary>
+            Gets or sets the subject encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.BodyEncoding">
+            <summary>
+            Gets or sets the body encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender.SmtpAuthentication">
+            <summary>
+            Values for the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property.
+            </summary>
+            <remarks>
+            <para>
+            SMTP authentication modes.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None">
+            <summary>
+            No authentication
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic">
+            <summary>
+            Basic authentication.
+            </summary>
+            <remarks>
+            Requires a username and password to be supplied
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm">
+            <summary>
+            Integrated authentication
+            </summary>
+            <remarks>
+            Uses the Windows credentials from the current thread or process to authenticate.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpPickupDirAppender">
+            <summary>
+            Send an email when a specific logging event occurs, typically on errors 
+            or fatal errors. Rather than sending via smtp it writes a file into the
+            directory specified by <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>. This allows services such
+            as the IIS SMTP agent to manage sending the messages.
+            </summary>
+            <remarks>
+            <para>
+            The configuration for this appender is identical to that of the <c>SMTPAppender</c>,
+            except that instead of specifying the <c>SMTPAppender.SMTPHost</c> you specify
+            <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>.
+            </para>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpPickupDirAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            </remarks>
+            <author>Niall Daley</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+            <remarks>
+            <para>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions">
+            <summary>
+            Activate the options on this appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpPickupDirAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.To">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.PickupDir">
+            <summary>
+            Gets or sets the path to write the messages to.
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the path to write the messages to. This should be the same
+            as that used by the agent sending the messages.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.FileExtension">
+            <summary>
+            Gets or sets the file extension for the generated files
+            </summary>
+            <value>
+            The file extension for the generated files
+            </value>
+            <remarks>
+            <para>
+            The file extension for the generated files
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender">
+            <summary>
+            Appender that allows clients to connect via Telnet to receive log messages
+            </summary>
+            <remarks>	
+            <para>
+            The TelnetAppender accepts socket connections and streams logging messages
+            back to the client.  
+            The output is provided in a telnet-friendly way so that a log can be monitored 
+            over a TCP/IP socket.
+            This allows simple remote monitoring of application logging.
+            </para>
+            <para>
+            The default <see cref="P:log4net.Appender.TelnetAppender.Port"/> is 23 (the telnet port).
+            </para>
+            </remarks>
+            <author>Keith Long</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TelnetAppender.declaringType">
+            <summary>
+            The fully qualified type of the TelnetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.OnClose">
+            <summary>
+            Overrides the parent method to close the socket handler
+            </summary>
+            <remarks>
+            <para>
+            Closes all the outstanding connections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Create the socket handler and wait for connections
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to each connected client.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to each connected client.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.Port">
+            <summary>
+            Gets or sets the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </value>
+            <remarks>
+            <para>
+            The default value is 23 (the telnet port).
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler">
+            <summary>
+            Helper class to manage connected clients
+            </summary>
+            <remarks>
+            <para>
+            The SocketHandler class is used to accept connections from
+            clients.  It is threaded so that clients can connect/disconnect
+            asynchronously.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.#ctor(System.Int32)">
+            <summary>
+            Opens a new server port on <paramref ref="port"/>
+            </summary>
+            <param name="port">the local port to listen on for connections</param>
+            <remarks>
+            <para>
+            Creates a socket handler on the specified local server port.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Send(System.String)">
+            <summary>
+            Sends a string message to each of the connected clients
+            </summary>
+            <param name="message">the text to send</param>
+            <remarks>
+            <para>
+            Sends a string message to each of the connected clients
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.AddClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Add a client to the internal clients list
+            </summary>
+            <param name="client">client to add</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.RemoveClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Remove a client from the internal clients list
+            </summary>
+            <param name="client">client to remove</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.OnConnect(System.IAsyncResult)">
+            <summary>
+            Callback used to accept a connection on the server socket
+            </summary>
+            <param name="asyncResult">The result of the asynchronous operation</param>
+            <remarks>
+            <para>
+            On connection adds to the list of connections 
+            if there are two many open connections you will be disconnected
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Dispose">
+            <summary>
+            Close all network connections
+            </summary>
+            <remarks>
+            <para>
+            Make sure we close all network connections
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.SocketHandler.HasConnections">
+            <summary>
+            Test if this handler has active connections
+            </summary>
+            <value>
+            <c>true</c> if this handler has active connections
+            </value>
+            <remarks>
+            <para>
+            This property will be <c>true</c> while this handler has
+            active connections, that is at least one connection that 
+            the handler will attempt to send a message to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient">
+            <summary>
+            Class that represents a client connected to this handler
+            </summary>
+            <remarks>
+            <para>
+            Class that represents a client connected to this handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.#ctor(System.Net.Sockets.Socket)">
+            <summary>
+            Create this <see cref="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient"/> for the specified <see cref="T:System.Net.Sockets.Socket"/>
+            </summary>
+            <param name="socket">the client's socket</param>
+            <remarks>
+            <para>
+            Opens a stream writer on the socket.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Send(System.String)">
+            <summary>
+            Write a string to the client
+            </summary>
+            <param name="message">string to send</param>
+            <remarks>
+            <para>
+            Write a string to the client
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Dispose">
+            <summary>
+            Cleanup the clients connection
+            </summary>
+            <remarks>
+            <para>
+            Close the socket connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TraceAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Trace"/> class for details on configuring the
+            trace system.
+            </para>
+            <para>
+            Events are written using the <c>System.Diagnostics.Trace.Write(string,string)</c>
+            method. The event's logger name is the default value for the category parameter 
+            of the Write method. 
+            </para>
+            <para>
+            <b>Compact Framework</b><br/>
+            The Compact Framework does not support the <see cref="T:System.Diagnostics.Trace"/>
+            class for any operation except <c>Assert</c>. When using the Compact Framework this
+            appender will write to the <see cref="T:System.Diagnostics.Debug"/> system rather than
+            the Trace system. This appender will therefore behave like the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </para>
+            </remarks>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.AliasDomainAttribute">
+            <summary>
+            Assembly level attribute that specifies a domain to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.DomainAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's domain to its repository by
+            specifying this attribute with the name of the target domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required domains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.AliasRepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies a repository to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.RepositoryAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's repository to its repository by
+            specifying this attribute with the name of the target repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required repositories.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.AliasRepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </summary>
+            <param name="name">The repository to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.AliasRepositoryAttribute.Name">
+            <summary>
+            Gets or sets the repository to alias to this assemby's repository.
+            </summary>
+            <value>
+            The repository to alias to this assemby's repository.
+            </value>
+            <remarks>
+            <para>
+            The name of the repository to alias to this assemby's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.AliasDomainAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasDomainAttribute"/> class with 
+            the specified domain to alias to this assembly's repository.
+            </summary>
+            <param name="name">The domain to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Obsolete. Use <see cref="T:log4net.Config.AliasRepositoryAttribute"/> instead of <see cref="T:log4net.Config.AliasDomainAttribute"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.BasicConfigurator">
+            <summary>
+            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </summary>
+            <remarks>
+            <para>
+            Allows very simple programmatic configuration of log4net.
+            </para>
+            <para>
+            Only one appender can be configured using this configurator.
+            The appender is set at the root of the hierarchy and all logging
+            events will be delivered to that appender.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Config.BasicConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the BasicConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.BasicConfigurator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure">
+            <summary>
+            Initializes the log4net system with a default configuration.
+            </summary>
+            <remarks>
+            <para>
+            Initializes the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the log4net system using the specified appenders.
+            </summary>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initializes the log4net system using the specified appender.
+            </summary>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> with a default configuration.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Initializes the specified repository using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appenders.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.ConfiguratorAttribute">
+            <summary>
+            Base class for all log4net configuration attributes.
+            </summary>
+            <remarks>
+            This is an abstract class that must be extended by 
+            specific configurators. This attribute allows the
+            configurator to be parameterized by an assembly level
+            attribute.
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">
+            <summary>
+            Constructor used by subclasses.
+            </summary>
+            <param name="priority">the ordering priority for this configurator</param>
+            <remarks>
+            <para>
+            The <paramref name="priority"/> is used to order the configurator
+            attributes before they are invoked. Higher priority configurators are executed
+            before lower priority ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Abstract method implemented by a subclass. When this method is called
+            the subclass should configure the <paramref name="targetRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">
+            <summary>
+            Compare this instance to another ConfiguratorAttribute
+            </summary>
+            <param name="obj">the object to compare to</param>
+            <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>
+            <remarks>
+            <para>
+            Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.
+            Sorts by priority in descending order. Objects with the same priority are
+            randomly ordered.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DomainAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging domain for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            <b>DomainAttribute is obsolete. Use RepositoryAttribute instead of DomainAttribute.</b>
+            </para>
+            <para>
+            Assemblies are mapped to logging domains. Each domain has its own
+            logging repository. This attribute specified on the assembly controls
+            the configuration of the domain. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the repository objects to create for the domain. If 
+            this attribute is not specified and a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> is not specified
+            then the assembly will be part of the default shared logging domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.RepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging repository for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            Assemblies are mapped to logging repository. This attribute specified 
+            on the assembly controls
+            the configuration of the repository. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the repository that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the <see cref="T:log4net.Repository.ILoggerRepository"/> object 
+            to create for the assembly. If this attribute is not specified or a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> 
+            is not specified then the assembly will be part of the default shared logging repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class 
+            with the name of the repository.
+            </summary>
+            <param name="name">The name of the repository.</param>
+            <remarks>
+            <para>
+            Initialize the attribute with the name for the assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.Name">
+            <summary>
+            Gets or sets the name of the logging repository.
+            </summary>
+            <value>
+            The string name to use as the name of the repository associated with this
+            assembly.
+            </value>
+            <remarks>
+            <para>
+            This value does not have to be unique. Several assemblies can share the
+            same repository. They will share the logging configuration of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.RepositoryType">
+            <summary>
+            Gets or sets the type of repository to create for this assembly.
+            </summary>
+            <value>
+            The type of repository to create for this assembly.
+            </value>
+            <remarks>
+            <para>
+            The type of the repository to create for the assembly.
+            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            interface.
+            </para>
+            <para>
+            This will be the type of repository created when 
+            the repository is created. If multiple assemblies reference the
+            same repository then the repository is only created once using the
+            <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/> of the first assembly to call into the 
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class 
+            with the name of the domain.
+            </summary>
+            <param name="name">The name of the domain.</param>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DOMConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="T:log4net.Config.DOMConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.XmlConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            <para>
+            If neither of the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>
+            properties are set the configuration is loaded from the application's .config file.
+            If set the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property takes priority over the
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property. The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property
+            specifies a path to a file to load the config from. The path is relative to the
+            application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property is used as a postfix to the assembly file name.
+            The config file must be located in the  application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            For example in a console application setting the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> to
+            <c>config</c> has the same effect as not specifying the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or 
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> properties.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.Watch"/> property can be set to cause the <see cref="T:log4net.Config.XmlConfigurator"/>
+            to watch the configuration file for changes.
+            </para>
+            <note>
+            <para>
+            Log4net will only look for assembly level configuration attributes once.
+            When using the log4net assembly level attributes to control the configuration 
+            of log4net you must ensure that the first call to any of the 
+            <see cref="T:log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration
+            attributes. 
+            </para>
+            <para>
+            If you cannot guarantee the order in which log4net calls will be made from 
+            different assemblies you must use programmatic configuration instead, i.e.
+            call the <see cref="M:XmlConfigurator.Configure()"/> method directly.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Configure the repository using the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            The <paramref name="targetRepository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>
+            class otherwise the <see cref="T:log4net.Config.XmlConfigurator"/> will not be able to
+            configure it.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="targetRepository"/> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.</exception>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from the local file system
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configure the specified repository using a <see cref="T:System.IO.FileInfo"/>
+            </summary>
+            <param name="targetRepository">The repository to configure.</param>
+            <param name="configFile">the FileInfo pointing to the config file</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromUri(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from a URI
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="F:log4net.Config.XmlConfiguratorAttribute.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfiguratorAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile">
+            <summary>
+            Gets or sets the filename of the configuration file.
+            </summary>
+            <value>
+            The filename of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified, this is the name of the configuration file to use with
+            the <see cref="T:log4net.Config.XmlConfigurator"/>. This file path is relative to the
+            <b>application base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>).
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension">
+            <summary>
+            Gets or sets the extension of the configuration file.
+            </summary>
+            <value>
+            The extension of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified this is the extension for the configuration file.
+            The path to the config file is built by using the <b>application 
+            base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>),
+            the <b>assembly file name</b> and the config file extension.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> is set to <c>MyExt</c> then
+            possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or
+            <c>MyClassLibrary.dll.MyExt</c>.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.Watch">
+            <summary>
+            Gets or sets a value indicating whether to watch the configuration file.
+            </summary>
+            <value>
+            <c>true</c> if the configuration should be watched, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            If this flag is specified and set to <c>true</c> then the framework
+            will watch the configuration file and will reload the config each time 
+            the file is modified.
+            </para>
+            <para>
+            The config file can only be watched if it is loaded from local disk.
+            In a No-Touch (Smart Client) deployment where the application is downloaded
+            from a web server the config file may not reside on the local disk
+            and therefore it may not be able to watch it.
+            </para>
+            <note>
+            Watching configuration is not supported on the SSCLI.
+            </note>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
+            <summary>
+            Class to register for the log4net section of the configuration file
+            </summary>
+            <remarks>
+            The log4net section of the configuration file needs to have a section
+            handler registered. This is the section handler used. It simply returns
+            the XML element that is the root of the section.
+            </remarks>
+            <example>
+            Example of registering the log4net section handler :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<configSections>
+            		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
+            	</configSections>
+            	<log4net>
+            		log4net configuration XML goes here
+            	</log4net>
+            </configuration>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
+            <summary>
+            Parses the configuration section.
+            </summary>
+            <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
+            <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>
+            <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>
+            <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.PluginAttribute">
+            <summary>
+            Assembly level attribute that specifies a plugin to attach to 
+            the repository.
+            </summary>
+            <remarks>
+            <para>
+            Specifies the type of a plugin to create and attach to the
+            assembly's repository. The plugin type must implement the
+            <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Plugin.IPluginFactory">
+            <summary>
+            Interface used to create plugins.
+            </summary>
+            <remarks>
+            <para>
+            Interface used to create  a plugin.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPluginFactory.CreatePlugin">
+            <summary>
+            Creates the plugin object.
+            </summary>
+            <returns>the new plugin instance</returns>
+            <remarks>
+            <para>
+            Create and return a new plugin instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="typeName">The type name of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            <para>
+            Where possible use the constructor that takes a <see cref="T:System.Type"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.Type)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="type">The type of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.CreatePlugin">
+            <summary>
+            Creates the plugin object defined by this attribute.
+            </summary>
+            <remarks>
+            <para>
+            Creates the instance of the <see cref="T:log4net.Plugin.IPlugin"/> object as 
+            specified by this attribute.
+            </para>
+            </remarks>
+            <returns>The plugin object.</returns>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.ToString">
+            <summary>
+            Returns a representation of the properties of this object.
+            </summary>
+            <remarks>
+            <para>
+            Overrides base class <see cref="M:Object.ToString()" /> method to 
+            return a representation of the properties of this object.
+            </para>
+            </remarks>
+            <returns>A representation of the properties of this object</returns>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.Type">
+            <summary>
+            Gets or sets the type for the plugin.
+            </summary>
+            <value>
+            The type for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type for the plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.TypeName">
+            <summary>
+            Gets or sets the type name for the plugin.
+            </summary>
+            <value>
+            The type name for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type name for the plugin.
+            </para>
+            <para>
+            Where possible use the <see cref="P:log4net.Config.PluginAttribute.Type"/> property instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.SecurityContextProviderAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">
+            <summary>
+            Construct provider attribute with type specified
+            </summary>
+            <param name="providerType">the type of the provider to use</param>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the SecurityContextProvider
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.
+            Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.SecurityContextProviderAttribute.declaringType">
+            <summary>
+            The fully qualified type of the SecurityContextProviderAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">
+            <summary>
+            Gets or sets the type of the provider to use.
+            </summary>
+            <value>
+            the type of the provider to use.
+            </value>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Uri)">
+            <summary>
+            Configures log4net using the specified configuration URI.
+            </summary>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration data stream.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Uri)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            URI.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.InternalConfigureFromXml(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the specified repository using a <c>log4net</c> element.
+            </summary>
+            <param name="repository">The hierarchy to configure.</param>
+            <param name="element">The element to parse.</param>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            <para>
+            This method is ultimately called by one of the Configure methods 
+            to load the configuration from an <see cref="T:System.Xml.XmlElement"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.m_repositoryName2ConfigAndWatchHandler">
+            <summary>
+            Maps repository names to ConfigAndWatchHandler instances to allow a particular
+            ConfigAndWatchHandler to dispose of its FileSystemWatcher when a repository is 
+            reconfigured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler">
+            <summary>
+            Class used to watch config files.
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="T:System.IO.FileSystemWatcher"/> to monitor
+            changes to a specified file. Because multiple change notifications
+            may be raised when the file is modified, a timer is used to
+            compress the notifications into a single event. The timer
+            waits for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> time before delivering
+            the event notification. If any further <see cref="T:System.IO.FileSystemWatcher"/>
+            change notifications arrive while the timer is waiting it
+            is reset and waits again for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> to
+            elapse.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis">
+            <summary>
+            The default amount of time to wait after receiving notification
+            before reloading the config file.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_configFile">
+            <summary>
+            Holds the FileInfo used to configure the XmlConfigurator
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_repository">
+            <summary>
+            Holds the repository being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_timer">
+            <summary>
+            The timer used to compress the notification events.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_watcher">
+            <summary>
+            Watches file for changes. This object should be disposed when no longer
+            needed to free system handles on the watched resources.
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class to
+            watch a specified config file used to configure a repository.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The configuration file to watch.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.OnWatchedFileChange(System.Object)">
+            <summary>
+            Called by the timer when the configuration has been updated.
+            </summary>
+            <param name="state">null</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.Dispose">
+            <summary>
+            Release the handles held by the watcher and timer.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.CompactRepositorySelector">
+            <summary>
+            The implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface suitable
+            for use with the compact framework
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.IRepositorySelector"/> implementation is a simple
+            mapping between repository name and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            object.
+            </para>
+            <para>
+            The .NET Compact Framework 1.0 does not support retrieving assembly
+            level attributes therefore unlike the <c>DefaultRepositorySelector</c>
+            this selector does not examine the calling assembly for attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Core.IRepositorySelector">
+            <summary>
+            Interface used by the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.Core.IRepositorySelector"/> 
+            to specify the policy for selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> 
+            to return to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association. The results of this method must be repeatable, i.e.
+            when called again with the same arguments the result must be the
+            save value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the named <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repositoryName">The name to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            Lookup a named <see cref="T:log4net.Repository.ILoggerRepository"/>. This is the repository created by
+            calling <see cref="M:CreateRepository(string,Type)"/>.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="assembly">The assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository with the name specified.
+            </summary>
+            <param name="repositoryName">The name to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the name
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same name will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(Assembly, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(Assembly)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>
+            An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances created by 
+            this <see cref="T:log4net.Core.IRepositorySelector"/>.</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Create a new repository selector
+            </summary>
+            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new compact repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
+            </summary>
+            <param name="assembly">not used</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <param name="repositoryName">the name of the repository to lookup</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>. The default 
+            repository is <c>log4net-default-repository</c>. Other repositories 
+            must be created using the <see cref="M:CreateRepository(string, Type)"/>.
+            If the named repository does not exist an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> does not exist</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="assembly">not used</param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            If the <paramref name="repositoryType"/> is <c>null</c> then the
+            default repository type specified to the constructor is used.
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Create a new repository for the repository specified
+            </summary>
+            <param name="repositoryName">the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is null then the default repository type is used.</param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            <para>
+            If the named repository already exists an exception will be thrown.
+            </para>
+            <para>
+            If <paramref name="repositoryType"/> is <c>null</c> then the default 
+            repository type specified to the constructor is used.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> already exists</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.CompactRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the CompactRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notify the registered listeners that the repository has been created
+            </summary>
+            <param name="repository">The repository that has been created</param>
+            <remarks>
+            <para>
+            Raises the <event cref="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">LoggerRepositoryCreatedEvent</event>
+            event.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.DefaultRepositorySelector">
+            <summary>
+            The default implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Uses attributes defined on the calling assembly to determine how to
+            configure the hierarchy for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Creates a new repository selector.
+            </summary>
+            <param name="defaultRepositoryType">The type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null"/>.</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="repositoryAssembly">The assembly use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <remarks>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and the repository 
+            to create can be overridden by specifying the <see cref="T:log4net.Config.RepositoryAttribute"/> 
+            attribute on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> 
+            implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically configured using 
+            any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
+            the <paramref name="repositoryAssembly"/>.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.</returns>
+            <remarks>
+            <para>
+            Returns the named repository. If <paramref name="repositoryName"/> is <c>null</c>
+            a <see cref="T:System.ArgumentNullException"/> is thrown. If the repository 
+            does not exist a <see cref="T:log4net.Core.LogException"/> is thrown.
+            </para>
+            <para>
+            Use <see cref="M:CreateRepository(string, Type)"/> to create a repository.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> does not exist.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type,System.String,System.Boolean)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryName">The name to assign to the created repository</param>
+            <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is <see langword="null"/> then the default repository type is used.</param>
+            <returns>The new repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.AliasRepository(System.String,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Aliases a repository to an existing repository.
+            </summary>
+            <param name="repositoryAlias">The repository to alias.</param>
+            <param name="repositoryTarget">The repository that the repository is aliased to.</param>
+            <remarks>
+            <para>
+            The repository specified will be aliased to the repository when created. 
+            The repository must not already exist.
+            </para>
+            <para>
+            When the repository is created it must utilize the same repository type as 
+            the repository it is aliased to, otherwise the aliasing will fail.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="repositoryAlias"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repositoryTarget"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notifies the registered listeners that the repository has been created.
+            </summary>
+            <param name="repository">The repository that has been created.</param>
+            <remarks>
+            <para>
+            Raises the <see cref="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">
+            <summary>
+            Gets the repository name and repository type for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly that has a <see cref="T:log4net.Config.RepositoryAttribute"/>.</param>
+            <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>
+            <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>
+            <exception cref="T:System.ArgumentNullException"><paramref name="assembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the repository using information from the assembly.
+            </summary>
+            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>
+            attributes which define the configuration for the repository.</param>
+            <param name="repository">The repository to configure.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadPlugins(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined plugins on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to add the plugins to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadAliases(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined aliases on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to alias to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="F:log4net.Core.DefaultRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the DefaultRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ErrorCode">
+            <summary>
+            Defined error codes that can be passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Values passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.GenericFailure">
+            <summary>
+            A general error
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.WriteFailure">
+            <summary>
+            Error while writing output
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FlushFailure">
+            <summary>
+            Failed to flush file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.CloseFailure">
+            <summary>
+            Failed to close file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FileOpenFailure">
+            <summary>
+            Unable to open output file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.MissingLayout">
+            <summary>
+            No layout specified
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.AddressParseFailure">
+            <summary>
+            Failed to parse address
+            </summary>
+        </member>
+        <member name="T:log4net.Core.ExceptionEvaluator">
+            <summary>
+            An evaluator that triggers on an Exception type
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the type of the Exception
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to a Type in <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.    /// 
+            </para>
+            </remarks>
+            <author>Drew Schaeffer</author>
+        </member>
+        <member name="T:log4net.Core.ITriggeringEventEvaluator">
+            <summary>
+            Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action
+            </summary>
+            <remarks>
+            <para>
+            Implementations of this interface allow certain appenders to decide
+            when to perform an appender specific action.
+            </para>
+            <para>
+            The action or behavior triggered is defined by the implementation.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if this event triggers the action
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
+            <remarks>
+            <para>
+            Return <c>true</c> if this event triggers the action
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_type">
+            <summary>
+            The type that causes the trigger to fire.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_triggerOnSubclass">
+            <summary>
+            Causes subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/> to cause the trigger to fire.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor">
+            <summary>
+            Default ctor to allow dynamic creation through a configurator.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor(System.Type,System.Boolean)">
+            <summary>
+            Constructs an evaluator and initializes to trigger on <paramref name="exType"/>
+            </summary>
+            <param name="exType">the type that triggers this evaluator.</param>
+            <param name="triggerOnSubClass">If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.</param>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the logging event Exception 
+            Type is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the Exception Type of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.ExceptionType">
+            <summary>
+            The type that triggers this evaluator.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.TriggerOnSubclass">
+            <summary>
+            If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.IErrorHandler">
+            <summary>
+            Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.
+            </summary>
+            <remarks>
+            <para>
+            Error handling is a particularly tedious to get right because by
+            definition errors are hard to predict and to reproduce. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <param name="errorCode">The error code associated with the error.</param>
+            <remarks>
+            <para>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IFixingRequired">
+            <summary>
+            Interface for objects that require fixing.
+            </summary>
+            <remarks>
+            <para>
+            Interface that indicates that the object requires fixing before it
+            can be taken outside the context of the appender's 
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            When objects that implement this interface are stored 
+            in the context properties maps <see cref="T:log4net.GlobalContext"/>
+            <see cref="P:log4net.GlobalContext.Properties"/> and <see cref="T:log4net.ThreadContext"/>
+            <see cref="P:log4net.ThreadContext.Properties"/> are fixed 
+            (see <see cref="P:log4net.Core.LoggingEvent.Fix"/>) the <see cref="M:log4net.Core.IFixingRequired.GetFixedObject"/>
+            method will be called.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IFixingRequired.GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a portable instance object that represents the current
+            state of this object. The portable object can be stored
+            and logged from any thread with identical results.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILogger">
+            <summary>
+            Interface that all loggers implement
+            </summary>
+            <remarks>
+            <para>
+            This interface supports logging events and testing if a level
+            is enabled for logging.
+            </para>
+            <para>
+            These methods will not throw exceptions. Note to implementor, ensure
+            that the implementation of these methods cannot allow an exception
+            to be thrown to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">the exception to log, including its stack trace. Pass <c>null</c> to not log an exception.</param>
+            <remarks>
+            <para>
+            Generates a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="T:log4net.Core.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Name">
+            <summary>
+            Gets the name of the logger.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILoggerWrapper">
+            <summary>
+            Base interface for all wrappers
+            </summary>
+            <remarks>
+            <para>
+            Base interface for all wrappers.
+            </para>
+            <para>
+            All wrappers must implement this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Core.ILoggerWrapper.Logger">
+            <summary>
+            Get the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this
+            object. The <c>Logger</c> object may not 
+            be the same object as this object because of logger decorators.
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventHandler">
+            <summary>
+            Delegate used to handle logger repository creation event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Core.IRepositorySelector"/> which created the repository.</param>
+            <param name="e">The <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> event args
+            that holds the <see cref="T:log4net.Repository.ILoggerRepository"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> 
+            event is raised every time a <see cref="T:log4net.Repository.ILoggerRepository"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerRepositoryCreationEventArgs.m_repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggerRepositoryCreationEventArgs.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </summary>
+            <param name="repository">the <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created</param>
+            <remarks>
+            <para>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggerRepositoryCreationEventArgs.LoggerRepository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.Level">
+            <summary>
+            Defines the default set of levels recognized by the system.
+            </summary>
+            <remarks>
+            <para>
+            Each <see cref="T:log4net.Core.LoggingEvent"/> has an associated <see cref="T:log4net.Core.Level"/>.
+            </para>
+            <para>
+            Levels have a numeric <see cref="P:log4net.Core.Level.Value"/> that defines the relative 
+            ordering between levels. Two Levels with the same <see cref="P:log4net.Core.Level.Value"/> 
+            are deemed to be equivalent.
+            </para>
+            <para>
+            The levels that are recognized by log4net are set for each <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and each repository can have different levels defined. The levels are stored
+            in the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> on the repository. Levels are
+            looked up by name from the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>.
+            </para>
+            <para>
+            When logging at level INFO the actual level used is not <see cref="F:log4net.Core.Level.Info"/> but
+            the value of <c>LoggerRepository.LevelMap["INFO"]</c>. The default value for this is
+            <see cref="F:log4net.Core.Level.Info"/>, but this can be changed by reconfiguring the level map.
+            </para>
+            <para>
+            Each level has a <see cref="P:log4net.Core.Level.DisplayName"/> in addition to its <see cref="P:log4net.Core.Level.Name"/>. The 
+            <see cref="P:log4net.Core.Level.DisplayName"/> is the string that is written into the output log. By default
+            the display name is the same as the level name, but this can be used to alias levels
+            or to localize the log output.
+            </para>
+            <para>
+            Some of the predefined levels recognized by the system are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Off"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Fatal"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Error"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Warn"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Info"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Debug"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.All"/>.</description>
+            	</item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <param name="displayName">The display name for this level. This may be localized or otherwise different from the name</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.ToString">
+            <summary>
+            Returns the <see cref="T:System.String"/> representation of the current 
+            <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <returns>
+            A <see cref="T:System.String"/> representation of the current <see cref="T:log4net.Core.Level"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns the level <see cref="P:log4net.Core.Level.Name"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Equals(System.Object)">
+            <summary>
+            Compares levels.
+            </summary>
+            <param name="o">The object to compare against.</param>
+            <returns><c>true</c> if the objects are equal.</returns>
+            <remarks>
+            <para>
+            Compares the levels of <see cref="T:log4net.Core.Level"/> instances, and 
+            defers to base class if the target object is not a <see cref="T:log4net.Core.Level"/>
+            instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.GetHashCode">
+            <summary>
+            Returns a hash code
+            </summary>
+            <returns>A hash code for the current <see cref="T:log4net.Core.Level"/>.</returns>
+            <remarks>
+            <para>
+            Returns a hash code suitable for use in hashing algorithms and data 
+            structures like a hash table.
+            </para>
+            <para>
+            Returns the hash code of the level <see cref="P:log4net.Core.Level.Value"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.CompareTo(System.Object)">
+            <summary>
+            Compares this instance to a specified object and returns an 
+            indication of their relative values.
+            </summary>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> instance or <see langword="null"/> to compare with this instance.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description>This instance is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description>This instance is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description>
+            			<para>This instance is greater than <paramref name="r"/>.</para>
+            			<para>-or-</para>
+            			<para><paramref name="r"/> is <see langword="null"/>.</para>
+            			</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            <paramref name="r"/> must be an instance of <see cref="T:log4net.Core.Level"/> 
+            or <see langword="null"/>; otherwise, an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException"><paramref name="r"/> is not a <see cref="T:log4net.Core.Level"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Equality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have the same value.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is the same as the 
+            value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Inequality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have different values.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is different from
+            the value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Compare(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Compares two specified <see cref="T:log4net.Core.Level"/> instances.
+            </summary>
+            <param name="l">The first <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <param name="r">The second <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            two values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description><paramref name="l"/> is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description><paramref name="l"/> is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description><paramref name="l"/> is greater than <paramref name="r"/>.</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.Level.Off">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Off"/> level designates a higher level than all the rest.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Log4Net_Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Emergency">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fatal">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fatal"/> level designates very severe error events 
+            that will presumably lead the application to abort.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Alert">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Alert"/> level designates very severe error events. 
+            Take immediate action, alerts.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Critical">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Critical"/> level designates very severe error events. 
+            Critical condition, critical.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Severe">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Severe"/> level designates very severe error events.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Error">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Error"/> level designates error events that might 
+            still allow the application to continue running.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Warn">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Warn"/> level designates potentially harmful 
+            situations.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Notice">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Notice"/> level designates informational messages 
+            that highlight the progress of the application at the highest level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Info">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Info"/> level designates informational messages that 
+            highlight the progress of the application at coarse-grained level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Debug"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fine">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fine"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Trace">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Trace"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finer">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finer"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Verbose">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Verbose"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finest">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finest"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.All">
+            <summary>
+            The <see cref="F:log4net.Core.Level.All"/> level designates the lowest level possible.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.Level.Name">
+            <summary>
+            Gets the name of this level.
+            </summary>
+            <value>
+            The name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.Value">
+            <summary>
+            Gets the value of this level.
+            </summary>
+            <value>
+            The value of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the value of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.DisplayName">
+            <summary>
+            Gets the display name of this level.
+            </summary>
+            <value>
+            The display name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the display name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Core.Level"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ReadOnly(log4net.Core.LevelCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>LevelCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>LevelCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>LevelCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <c>LevelCollection</c>.
+            </summary>
+            <param name="c">The <c>LevelCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.Level[])">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Core.Level"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[])">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[],System.Int32)">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Add(log4net.Core.Level)">
+            <summary>
+            Adds a <see cref="T:log4net.Core.Level"/> to the end of the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to be added to the end of the <c>LevelCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clear">
+            <summary>
+            Removes all elements from the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Core.LevelCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Contains(log4net.Core.Level)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Core.Level"/> is in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.IndexOf(log4net.Core.Level)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Core.Level"/>
+            in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to locate in the <c>LevelCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>LevelCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Insert(System.Int32,log4net.Core.Level)">
+            <summary>
+            Inserts an element into the <c>LevelCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Remove(log4net.Core.Level)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Core.Level"/> from the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to remove from the <c>LevelCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Core.Level"/> was not found in the <c>LevelCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>LevelCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>LevelCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Core.LevelCollection.Enumerator"/> for the entire <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.LevelCollection)">
+            <summary>
+            Adds the elements of another <c>LevelCollection</c> to the current <c>LevelCollection</c>.
+            </summary>
+            <param name="x">The <c>LevelCollection</c> whose elements should be added to the end of the current <c>LevelCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.Level[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> array to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> collection to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.Level"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>LevelCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.ILevelCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LevelCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelEvaluator">
+            <summary>
+            An evaluator that triggers at a threshold level
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelEvaluator.m_threshold">
+            <summary>
+            The threshold for triggering
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor(log4net.Core.Level)">
+            <summary>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </summary>
+            <param name="threshold">the threshold to trigger at</param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the event level
+            is equal or higher than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelEvaluator.Threshold">
+            <summary>
+            the threshold to trigger at
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.Level"/> that will cause this evaluator to trigger
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelMap">
+            <summary>
+            Mapping between string name and Level object
+            </summary>
+            <remarks>
+            <para>
+            Mapping between string name and <see cref="T:log4net.Core.Level"/> object.
+            This mapping is held separately for each <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The level name is case insensitive.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelMap.m_mapName2Level">
+            <summary>
+            Mapping from level name to Level object. The
+            level name is case insensitive
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelMap.#ctor">
+            <summary>
+            Construct the level map
+            </summary>
+            <remarks>
+            <para>
+            Construct the level map.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Clear">
+            <summary>
+            Clear the internal maps of all levels
+            </summary>
+            <remarks>
+            <para>
+            Clear the internal maps of all levels
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+            <seealso cref="M:Add(string,int,string)"/>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32,System.String)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <param name="displayName">the display name to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(log4net.Core.Level)">
+            <summary>
+            Add a Level to the map
+            </summary>
+            <param name="level">the Level to add</param>
+            <remarks>
+            <para>
+            Add a Level to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.LookupWithDefault(log4net.Core.Level)">
+            <summary>
+            Lookup a named level from the map
+            </summary>
+            <param name="defaultLevel">the name of the level to lookup is taken from this level. 
+            If the level is not set on the map then this level is added</param>
+            <returns>the level in the map with the name specified</returns>
+            <remarks>
+            <para>
+            Lookup a named level from the map. The name of the level to lookup is taken
+            from the <see cref="P:log4net.Core.Level.Name"/> property of the <paramref name="defaultLevel"/>
+            argument.
+            </para>
+            <para>
+            If no level with the specified name is found then the 
+            <paramref name="defaultLevel"/> argument is added to the level map
+            and returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.Item(System.String)">
+            <summary>
+            Lookup a <see cref="T:log4net.Core.Level"/> by name
+            </summary>
+            <param name="name">The name of the Level to lookup</param>
+            <returns>a Level from the map with the name specified</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:log4net.Core.Level"/> from the
+            map with the name specified. If the no level is
+            found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.AllLevels">
+            <summary>
+            Return all possible levels as a list of Level objects.
+            </summary>
+            <returns>all possible levels as a list of Level objects</returns>
+            <remarks>
+            <para>
+            Return all possible levels as a list of Level objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LocationInfo">
+            <summary>
+            The internal representation of caller location information.
+            </summary>
+            <remarks>
+            <para>
+            This class uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.Type)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class based on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="className">The fully qualified class name.</param>
+            <param name="methodName">The method name.</param>
+            <param name="fileName">The file name.</param>
+            <param name="lineNumber">The line number of the method within the file.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class with the specified data.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.declaringType">
+            <summary>
+            The fully qualified type of the LocationInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.MethodName">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.StackFrames">
+            <summary>
+            Gets the stack frames from the stack trace of the caller making the log request
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LoggerManager">
+            <summary>
+            Static manager that controls the creation of repositories
+            </summary>
+            <remarks>
+            <para>
+            Static manager that controls the creation of repositories
+            </para>
+            <para>
+            This class is used by the wrapper managers (e.g. <see cref="T:log4net.LogManager"/>)
+            to provide access to the <see cref="T:log4net.Core.ILogger"/> objects.
+            </para>
+            <para>
+            This manager also holds the <see cref="T:log4net.Core.IRepositorySelector"/> that is used to
+            lookup and create repositories. The selector can be set either programmatically using
+            the <see cref="P:log4net.Core.LoggerManager.RepositorySelector"/> property, or by setting the <c>log4net.RepositorySelector</c>
+            AppSetting in the applications config file to the fully qualified type name of the
+            selector to use. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#ctor">
+            <summary>
+            Private constructor to prevent instances. Only static methods should be used.
+            </summary>
+            <remarks>
+            <para>
+            Private constructor to prevent instances. Only static methods should be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#cctor">
+            <summary>
+            Hook the shutdown event
+            </summary>
+            <remarks>
+            <para>
+            On the full .NET runtime, the static constructor hooks up the 
+            <c>AppDomain.ProcessExit</c> and <c>AppDomain.DomainUnload</c>> events. 
+            These are used to shutdown the log4net system as the application exits.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.RegisterAppDomainEvents">
+            <summary>
+            Register for ProcessExit and DomainUnload events on the AppDomain
+            </summary>
+            <remarks>
+            <para>
+            This needs to be in a separate method because the events make
+            a LinkDemand for the ControlAppDomain SecurityPermission. Because
+            this is a LinkDemand it is demanded at JIT time. Therefore we cannot
+            catch the exception in the method itself, we have to catch it in the
+            caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified assembly's repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified assembly's repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to lookup the repository</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repository">The repository to shutdown.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repository">The repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+            <remarks>
+            <para>
+            Gets an array of all currently defined repositories.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetVersionInfo">
+            <summary>
+            Internal method to get pertinent version info.
+            </summary>
+            <returns>A string of version info.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnDomainUnload(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnProcessExit(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.declaringType">
+            <summary>
+            The fully qualified type of the LoggerManager class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.s_repositorySelector">
+            <summary>
+            Initialize the default repository selector
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerManager.RepositorySelector">
+            <summary>
+            Gets or sets the repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </summary>
+            <value>
+            The repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </value>
+            <remarks>
+            <para>
+            The repository selector (<see cref="T:log4net.Core.IRepositorySelector"/>) is used by 
+            the <see cref="T:log4net.LogManager"/> to create and select repositories 
+            (<see cref="T:log4net.Repository.ILoggerRepository"/>).
+            </para>
+            <para>
+            The caller to <see cref="T:log4net.LogManager"/> supplies either a string name 
+            or an assembly (if not supplied the assembly is inferred using 
+            <see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            <para>
+            This context is used by the selector to lookup a specific repository.
+            </para>
+            <para>
+            For the full .NET Framework, the default repository is <c>DefaultRepositorySelector</c>;
+            for the .NET Compact Framework <c>CompactRepositorySelector</c> is the default
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerWrapperImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.ILoggerWrapper"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This class should be used as the base for all wrapper implementations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerWrapperImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Constructs a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Constructs a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerWrapperImpl.m_logger">
+            <summary>
+            The logger that this object is wrapping
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerWrapperImpl.Logger">
+            <summary>
+            Gets the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that this object is implementing.
+            </value>
+            <remarks>
+            <para>
+            The <c>Logger</c> object may not be the same object as this object 
+            because of logger decorators.
+            </para>
+            <para>
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEventData">
+            <summary>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LoggerName">
+            <summary>
+            The logger name.
+            </summary>
+            <remarks>
+            <para>
+            The logger name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Level">
+            <summary>
+            Level of logging event.
+            </summary>
+            <remarks>
+            <para>
+            Level of logging event. Level cannot be Serializable
+            because it is a flyweight.  Due to its special serialization it
+            cannot be declared final either.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Message">
+            <summary>
+            The application supplied message.
+            </summary>
+            <remarks>
+            <para>
+            The application supplied message of logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ThreadName">
+            <summary>
+            The name of thread
+            </summary>
+            <remarks>
+            <para>
+            The name of thread in which this logging event was generated
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.TimeStamp">
+            <summary>
+            Gets or sets the local time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            Prefer using the <see cref="P:log4net.Core.LoggingEventData.TimeStampUtc"/> setter, since local time can be ambiguous.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LocationInfo">
+            <summary>
+            Location information for the caller.
+            </summary>
+            <remarks>
+            <para>
+            Location information for the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.UserName">
+            <summary>
+            String representation of the user
+            </summary>
+            <remarks>
+            <para>
+            String representation of the user's windows name,
+            like DOMAIN\username
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Identity">
+            <summary>
+            String representation of the identity.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the current thread's principal identity.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ExceptionString">
+            <summary>
+            The string representation of the exception
+            </summary>
+            <remarks>
+            <para>
+            The string representation of the exception
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Domain">
+            <summary>
+            String representation of the AppDomain.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Properties">
+            <summary>
+            Additional event specific properties
+            </summary>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEventData.TimeStampUtc">
+            <summary>
+            Gets or sets the UTC time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            The TimeStamp is stored in the UTC time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.FixFlags">
+            <summary>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </summary>
+            <remarks>
+            <para>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Mdc">
+            <summary>
+            Fix the MDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Ndc">
+            <summary>
+            Fix the NDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Message">
+            <summary>
+            Fix the rendered message
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.ThreadName">
+            <summary>
+            Fix the thread name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.LocationInfo">
+            <summary>
+            Fix the callers location information
+            </summary>
+            <remarks>
+            CAUTION: Very slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.UserName">
+            <summary>
+            Fix the callers windows user name
+            </summary>
+            <remarks>
+            CAUTION: Slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Domain">
+            <summary>
+            Fix the domain friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Identity">
+            <summary>
+            Fix the callers principal name
+            </summary>
+            <remarks>
+            CAUTION: May be slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Exception">
+            <summary>
+            Fix the exception text
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Properties">
+            <summary>
+            Fix the event properties. Active properties must implement <see cref="T:log4net.Core.IFixingRequired"/> in order to be eligible for fixing.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.None">
+            <summary>
+            No fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.All">
+            <summary>
+            All fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Partial">
+            <summary>
+            Partial fields fixed
+            </summary>
+            <remarks>
+            <para>
+            This set of partial fields gives good performance. The following fields are fixed:
+            </para>
+            <list type="bullet">
+            <item><description><see cref="F:log4net.Core.FixFlags.Message"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.ThreadName"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Exception"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Domain"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Properties"/></description></item>
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEvent">
+            <summary>
+            The internal representation of logging events. 
+            </summary>
+            <remarks>
+            <para>
+            When an affirmative decision is made to log then a 
+            <see cref="T:log4net.Core.LoggingEvent"/> instance is created. This instance 
+            is passed around to the different log4net components.
+            </para>
+            <para>
+            This class is of concern to those wishing to extend log4net.
+            </para>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.HostNameProperty">
+            <summary>
+            The key into the Properties map for the host name value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.IdentityProperty">
+            <summary>
+            The key into the Properties map for the thread identity value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.UserNameProperty">
+            <summary>
+            The key into the Properties map for the user name value.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,System.String,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class
+            from the supplied parameters.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="loggerName">The name of the logger of this event.</param>
+            <param name="level">The level of this event.</param>
+            <param name="message">The message of this event.</param>
+            <param name="exception">The exception for this event.</param>
+            <remarks>
+            <para>
+            Except <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.Core.LoggingEvent.Level"/> and <see cref="P:log4net.Core.LoggingEvent.LoggerName"/>, 
+            all fields of <c>LoggingEvent</c> are filled when actually needed. Call
+            <see cref="M:FixVolatileData()"/> to cache all data locally
+            to prevent inconsistencies.
+            </para>
+            <para>This method is called by the log4net framework
+            to create a logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData,log4net.Core.FixFlags)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            The <paramref name="fixedData"/> parameter should be used to specify which fields in the
+            <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>
+            will be captured from the environment if requested or fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.EnsureRepository(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Ensure that the repository is set.
+            </summary>
+            <param name="repository">the value for the repository</param>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)">
+            <summary>
+            Write the rendered message to a TextWriter
+            </summary>
+            <param name="writer">the writer to write the message to</param>
+            <remarks>
+            <para>
+            Unlike the <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property this method
+            does store the message data in the internal cache. Therefore 
+            if called only once this method should be faster than the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property, however if the message is
+            to be accessed multiple times then the property will be more efficient.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            The data in this event must be fixed before it can be serialized.
+            </para>
+            <para>
+            The <see cref="M:FixVolatileData()"/> method must be called during the
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method call if this event 
+            is to be used outside that method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            <para>
+            Does a <see cref="F:log4net.Core.FixFlags.Partial"/> fix of the data
+            in the logging event before returning the event data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData(log4net.Core.FixFlags)">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionStrRep">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            <b>Obsolete. Use <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> instead.</b>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionString">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData">
+            <summary>
+            Fix instance fields that hold volatile data.
+            </summary>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            Calling <see cref="M:FixVolatileData()"/> is equivalent to
+            calling <see cref="M:FixVolatileData(bool)"/> passing the parameter
+            <c>false</c>.
+            </para>
+            <para>
+            See <see cref="M:FixVolatileData(bool)"/> for more
+            information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)">
+            <summary>
+            Fixes instance fields that hold volatile data.
+            </summary>
+            <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            The <paramref name="fastButLoose"/> param controls the data that
+            is fixed. Some of the data that can be fixed takes a long time to 
+            generate, therefore if you do not require those settings to be fixed
+            they can be ignored by setting the <paramref name="fastButLoose"/> param
+            to <c>true</c>. This setting will ignore the <see cref="P:log4net.Core.LoggingEvent.LocationInformation"/>
+            and <see cref="P:log4net.Core.LoggingEvent.UserName"/> settings.
+            </para>
+            <para>
+            Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all 
+            settings are fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)">
+            <summary>
+            Fix the fields specified by the <see cref="T:log4net.Core.FixFlags"/> parameter
+            </summary>
+            <param name="flags">the fields to fix</param>
+            <remarks>
+            <para>
+            Only fields specified in the <paramref name="flags"/> will be fixed.
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.LookupProperty(System.String)">
+            <summary>
+            Lookup a composite property in this event
+            </summary>
+            <param name="key">the key for the property to lookup</param>
+            <returns>the value for the property</returns>
+            <remarks>
+            <para>
+            This event has composite properties that combine together properties from
+            several different contexts in the following order:
+            <list type="definition">
+            	<item>
+            		<term>this events properties</term>
+            		<description>
+            		This event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            		properties are specific to this event only.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the thread properties</term>
+            		<description>
+            		The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            		thread. These properties are shared by all events logged on this thread.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the global properties</term>
+            		<description>
+            		The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            		properties are shared by all the threads in the AppDomain.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetProperties">
+            <summary>
+            Get all the composite properties in this event
+            </summary>
+            <returns>the <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the properties</returns>
+            <remarks>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/> for details of the composite properties 
+            stored by the event.
+            </para>
+            <para>
+            This method returns a single <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the
+            properties defined for this event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_data">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_compositeProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_eventProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_callerStackBoundaryDeclaringType">
+            <summary>
+            The fully qualified Type of the calling 
+            logger class in the stack frame (i.e. the declaring type of the method).
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_message">
+            <summary>
+            The application supplied message of logging event.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_thrownException">
+            <summary>
+            The exception that was thrown.
+            </summary>
+            <remarks>
+            This is not serialized. The string representation
+            is serialized instead.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_repository">
+            <summary>
+            The repository that generated the logging event
+            </summary>
+            <remarks>
+            This is not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_fixFlags">
+            <summary>
+            The fix state for this event
+            </summary>
+            <remarks>
+            These flags indicate which fields have been fixed.
+            Not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_cacheUpdatable">
+            <summary>
+            Indicated that the internal cache is updateable (ie not fixed)
+            </summary>
+            <remarks>
+            This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler
+            changes in the caching strategy.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTime">
+            <summary>
+            Gets the time when the current process started.
+            </summary>
+            <value>
+            This is the time when this process started.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored internally in UTC and converted to the local time zone for this computer.
+            </para>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTimeUtc">
+            <summary>
+            Gets the UTC time when the current process started.
+            </summary>
+            <value>
+            This is the UTC time when this process started.
+            </value>
+            <remarks>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Level">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStamp">
+            <summary>
+            Gets the time of the logging event.
+            </summary>
+            <value>
+            The time of the logging event.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored in UTC and converted to the local time zone for this computer.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStampUtc">
+            <summary>
+            Gets UTC the time of the logging event.
+            </summary>
+            <value>
+            The UTC time of the logging event.
+            </value>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LoggerName">
+            <summary>
+            Gets the name of the logger that logged the event.
+            </summary>
+            <value>
+            The name of the logger that logged the event.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of the logger that logged the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LocationInformation">
+            <summary>
+            Gets the location information for this logging event.
+            </summary>
+            <value>
+            The location information for this logging event.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Core.LocationInfo"/> class for more information on
+            supported frameworks and the different behavior in Debug and
+            Release builds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.MessageObject">
+            <summary>
+            Gets the message object used to initialize this event.
+            </summary>
+            <value>
+            The message object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the message object used to initialize this event.
+            Note that this event may not have a valid message object.
+            If the event is serialized the message object will not 
+            be transferred. To get the text of the message the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined message object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ExceptionObject">
+            <summary>
+            Gets the exception object used to initialize this event.
+            </summary>
+            <value>
+            The exception object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the exception object used to initialize this event.
+            Note that this event may not have a valid exception object.
+            If the event is serialized the exception object will not 
+            be transferred. To get the text of the exception the
+            <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> method must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined exception object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.RenderedMessage">
+            <summary>
+            Gets the message, rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <value>
+            The message rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ThreadName">
+            <summary>
+            Gets the name of the current thread.  
+            </summary>
+            <value>
+            The name of the current thread, or the thread ID when 
+            the name is not available.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.UserName">
+            <summary>
+            Gets the name of the current user.
+            </summary>
+            <value>
+            The name of the current user, or <c>NOT AVAILABLE</c> when the 
+            underlying runtime has no support for retrieving the name of the 
+            current user.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of
+            the current windows user.
+            </para>
+            <para>
+            To improve performance, we could cache the string representation of 
+            the name, and reuse that as long as the identity stayed constant.  
+            Once the identity changed, we would need to re-assign and re-render 
+            the string.
+            </para>
+            <para>
+            However, the <c>WindowsIdentity.GetCurrent()</c> call seems to 
+            return different objects every time, so the current implementation 
+            doesn't do this type of caching.
+            </para>
+            <para>
+            Timing for these operations:
+            </para>
+            <list type="table">
+              <listheader>
+                <term>Method</term>
+                <description>Results</description>
+              </listheader>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent()</c></term>
+                <description>10000 loops, 00:00:00.2031250 seconds</description>
+              </item>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent().Name</c></term>
+                <description>10000 loops, 00:00:08.0468750 seconds</description>
+              </item>
+            </list>
+            <para>
+            This means we could speed things up almost 40 times by caching the 
+            value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since 
+            this takes (8.04-0.20) = 7.84375 seconds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Identity">
+            <summary>
+            Gets the identity of the current thread principal.
+            </summary>
+            <value>
+            The string name of the identity of the current thread principal.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get
+            the name of the current thread principal.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Domain">
+            <summary>
+            Gets the AppDomain friendly name.
+            </summary>
+            <value>
+            The AppDomain friendly name.
+            </value>
+            <remarks>
+            <para>
+            Gets the AppDomain friendly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Properties">
+            <summary>
+            Additional event specific properties.
+            </summary>
+            <value>
+            Additional event specific properties.
+            </value>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            <para>
+            This property is for events that have been added directly to
+            this event. The aggregate properties (which include these
+            event properties) can be retrieved using <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/>
+            and <see cref="M:log4net.Core.LoggingEvent.GetProperties"/>.
+            </para>
+            <para>
+            Once the properties have been fixed <see cref="P:log4net.Core.LoggingEvent.Fix"/> this property
+            returns the combined cached properties. This ensures that updates to
+            this property are always reflected in the underlying storage. When
+            returning the combined properties there may be more keys in the
+            Dictionary than expected.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Fix">
+            <summary>
+            The fixed fields in this event
+            </summary>
+            <value>
+            The set of fields that are fixed in this event
+            </value>
+            <remarks>
+            <para>
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LogImpl">
+            <summary>
+            Implementation of <see cref="T:log4net.ILog"/> wrapper interface.
+            </summary>
+            <remarks>
+            <para>
+            This implementation of the <see cref="T:log4net.ILog"/> interface
+            forwards to the <see cref="T:log4net.Core.ILogger"/> held by the base class.
+            </para>
+            <para>
+            This logger has methods to allow the caller to log at the following
+            levels:
+            </para>
+            <list type="definition">
+              <item>
+                <term>DEBUG</term>
+                <description>
+                The <see cref="M:Debug(object)"/> and <see cref="M:DebugFormat(string, object[])"/> methods log messages
+                at the <c>DEBUG</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Debug"/>. The <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>INFO</term>
+                <description>
+                The <see cref="M:Info(object)"/> and <see cref="M:InfoFormat(string, object[])"/> methods log messages
+                at the <c>INFO</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Info"/>. The <see cref="P:log4net.Core.LogImpl.IsInfoEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>WARN</term>
+                <description>
+                The <see cref="M:Warn(object)"/> and <see cref="M:WarnFormat(string, object[])"/> methods log messages
+                at the <c>WARN</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Warn"/>. The <see cref="P:log4net.Core.LogImpl.IsWarnEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>ERROR</term>
+                <description>
+                The <see cref="M:Error(object)"/> and <see cref="M:ErrorFormat(string, object[])"/> methods log messages
+                at the <c>ERROR</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Error"/>. The <see cref="P:log4net.Core.LogImpl.IsErrorEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>FATAL</term>
+                <description>
+                The <see cref="M:Fatal(object)"/> and <see cref="M:FatalFormat(string, object[])"/> methods log messages
+                at the <c>FATAL</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Fatal"/>. The <see cref="P:log4net.Core.LogImpl.IsFatalEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+            </list>
+            <para>
+            The values for these levels and their semantic meanings can be changed by 
+            configuring the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ILog">
+            <summary>
+            The ILog interface is use by application to log messages into
+            the log4net framework.
+            </summary>
+            <remarks>
+            <para>
+            Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
+            that implement this interface. The <see cref="M:LogManager.GetLogger(Assembly,Type)"/>
+            static method is used to get logger instances.
+            </para>
+            <para>
+            This class contains methods for logging at different levels and also
+            has properties for determining if those logging levels are
+            enabled in the current configuration.
+            </para>
+            <para>
+            This interface can be implemented in different ways. This documentation
+            specifies reasonable behavior that a caller can expect from the actual
+            implementation, however different implementations reserve the right to
+            do things differently.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <seealso cref="T:log4net.LogManager"/>
+            <seealso cref="M:LogManager.GetLogger(Assembly, Type)"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">
+            <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para> For some ILog interface <c>log</c>, when you write:</para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, string construction and concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed (who isn't), then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
+            the <see cref="M:Debug(object)"/>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log. This is the preferred style of logging.
+            </para>
+            <para>Alternatively if your logger is available statically then the is debug
+            enabled state can be stored in a static variable like this:
+            </para>
+            <code lang="C#">
+            private static readonly bool isDebugEnabled = log.IsDebugEnabled;
+            </code>
+            <para>
+            Then when you come to log you can write:
+            </para>
+            <code lang="C#">
+            if (isDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way the debug enabled state is only queried once
+            when the class is loaded. Using a <c>private static readonly</c>
+            variable is the most efficient because it is a run time constant
+            and can be heavily optimized by the JIT compiler.
+            </para>
+            <para>
+            Of course if you use a static readonly variable to
+            hold the enabled state of the logger then you cannot
+            change the enabled state at runtime to vary the logging
+            that is produced. You have to decide if you need absolute
+            speed or runtime flexibility.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="M:DebugFormat(IFormatProvider, string, object[])"/>
+        </member>
+        <member name="P:log4net.ILog.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="M:InfoFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="M:WarnFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="M:ErrorFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="M:FatalFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Construct a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Construct a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ReloadLevels(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Virtual method called when the configuration of the repository changes
+            </summary>
+            <param name="repository">the repository holding the levels</param>
+            <remarks>
+            <para>
+            Virtual method called when the configuration of the repository changes
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <c>DEBUG</c> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>DEBUG</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> passed
+            as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <c>INFO</c> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level.
+            </summary>
+            <param name="message">the message object to log</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <c>WARN</c> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>WARN</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <c>ERROR</c> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>ERROR</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <c>FATAL</c> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>FATAL</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.LoggerRepositoryConfigurationChanged(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for the <see cref="E:log4net.Repository.ILoggerRepository.ConfigurationChanged"/> event
+            </summary>
+            <param name="sender">the repository</param>
+            <param name="e">Empty</param>
+        </member>
+        <member name="F:log4net.Core.LogImpl.ThisDeclaringType">
+            <summary>
+            The fully qualified name of this declaring type not the type of any subclass.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>DEBUG</c>
+            level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>DEBUG</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para>
+            For some <c>log</c> Logger object, when you write:
+            </para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed, then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled())
+            { 
+             log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <c>IsDebugEnabled</c> and once in
+            the <c>Debug</c>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>INFO</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>INFO</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>WARN</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>WARN</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>ERROR</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>ERROR</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>FATAL</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>FATAL</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="T:log4net.Core.MethodItem">
+            <summary>
+            provides method information without actually referencing a System.Reflection.MethodBase
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.MethodItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor">
+            <summary>
+            constructs a method item for an unknown method.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String)">
+            <summary>
+            constructs a method item from the name of the method.
+            </summary>
+            <param name="name"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String,System.String[])">
+            <summary>
+            constructs a method item from the name of the method and its parameters.
+            </summary>
+            <param name="name"></param>
+            <param name="parameters"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.Reflection.MethodBase)">
+            <summary>
+            constructs a method item from a method base by determining the method name and its parameters.
+            </summary>
+            <param name="methodBase"></param>
+        </member>
+        <member name="F:log4net.Core.MethodItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Name">
+            <summary>
+            Gets the method name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The method name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Parameters">
+            <summary>
+            Gets the method parameters of the caller making
+            the logging request.
+            </summary>
+            <value>
+            The method parameters of the caller making
+            the logging request
+            </value>
+            <remarks>
+            <para>
+            Gets the method parameters of the caller making
+            the logging request.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContext">
+            <summary>
+            A SecurityContext used by log4net when interacting with protected resources
+            </summary>
+            <remarks>
+            <para>
+            A SecurityContext used by log4net when interacting with protected resources
+            for example with operating system services. This can be used to impersonate
+            a principal that has been granted privileges on the system resources.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.SecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns>An <see cref="T:System.IDisposable"/> instance that will
+            revoke the impersonation of this SecurityContext, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Impersonate this security context. Further calls on the current
+            thread should now be made in the security context provided
+            by this object. When the <see cref="T:System.IDisposable"/> result 
+            <see cref="M:System.IDisposable.Dispose"/> method is called the security
+            context of the thread should be reverted to the state it was in
+            before <see cref="M:log4net.Core.SecurityContext.Impersonate(System.Object)"/> was called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContextProvider">
+            <summary>
+            The <see cref="T:log4net.Core.SecurityContextProvider"/> providers default <see cref="T:log4net.Core.SecurityContext"/> instances.
+            </summary>
+            <remarks>
+            <para>
+            A configured component that interacts with potentially protected system
+            resources uses a <see cref="T:log4net.Core.SecurityContext"/> to provide the elevated
+            privileges required. If the <see cref="T:log4net.Core.SecurityContext"/> object has
+            been not been explicitly provided to the component then the component
+            will request one from this <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </para>
+            <para>
+            By default the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is
+            an instance of <see cref="T:log4net.Core.SecurityContextProvider"/> which returns only
+            <see cref="T:log4net.Util.NullSecurityContext"/> objects. This is a reasonable default
+            where the privileges required are not know by the system.
+            </para>
+            <para>
+            This default behavior can be overridden by subclassing the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            and overriding the <see cref="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)"/> method to return
+            the desired <see cref="T:log4net.Core.SecurityContext"/> objects. The default provider
+            can be replaced by programmatically setting the value of the 
+            <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> property.
+            </para>
+            <para>
+            An alternative is to use the <c>log4net.Config.SecurityContextProviderAttribute</c>
+            This attribute can be applied to an assembly in the same way as the
+            <c>log4net.Config.XmlConfiguratorAttribute"</c>. The attribute takes
+            the type to use as the <see cref="T:log4net.Core.SecurityContextProvider"/> as an argument.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.SecurityContextProvider.s_defaultProvider">
+            <summary>
+            The default provider
+            </summary>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.#ctor">
+            <summary>
+            Protected default constructor to allow subclassing
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)">
+            <summary>
+            Create a SecurityContext for a consumer
+            </summary>
+            <param name="consumer">The consumer requesting the SecurityContext</param>
+            <returns>An impersonation context</returns>
+            <remarks>
+            <para>
+            The default implementation is to return a <see cref="T:log4net.Util.NullSecurityContext"/>.
+            </para>
+            <para>
+            Subclasses should override this method to provide their own
+            behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.SecurityContextProvider.DefaultProvider">
+            <summary>
+            Gets or sets the default SecurityContextProvider
+            </summary>
+            <value>
+            The default SecurityContextProvider
+            </value>
+            <remarks>
+            <para>
+            The default provider is used by configured components that
+            require a <see cref="T:log4net.Core.SecurityContext"/> and have not had one
+            given to them.
+            </para>
+            <para>
+            By default this is an instance of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that returns <see cref="T:log4net.Util.NullSecurityContext"/> objects.
+            </para>
+            <para>
+            The default provider can be set programmatically by setting
+            the value of this property to a sub class of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that has the desired behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.StackFrameItem">
+            <summary>
+            provides stack frame information without actually referencing a System.Diagnostics.StackFrame
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.StackFrameItem.#ctor(System.Diagnostics.StackFrame)">
+            <summary>
+            returns a stack frame item from a stack frame. This 
+            </summary>
+            <param name="frame"></param>
+            <returns></returns>
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.Method">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.TimeEvaluator">
+            <summary>
+            An evaluator that triggers after specified number of seconds.
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+            <author>Robert Sevcik</author>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL">
+            <summary>
+            The default time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_interval">
+            <summary>
+            The time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_lastTimeUtc">
+            <summary>
+            The UTC time of last check. This gets updated when the object is created and when the evaluator triggers.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor(System.Int32)">
+            <summary>
+            Create a new evaluator using the specified time threshold in seconds.
+            </summary>
+            <param name="interval">
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.TimeEvaluator.Interval">
+            <summary>
+            The time threshold in seconds to trigger after
+            </summary>
+            <value>
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperCreationHandler">
+            <summary>
+            Delegate used to handle creation of new wrappers.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <remarks>
+            <para>
+            Delegate used to handle creation of new wrappers. This delegate
+            is called from the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method to construct the wrapper for the specified logger.
+            </para>
+            <para>
+            The delegate to use is supplied to the <see cref="T:log4net.Core.WrapperMap"/>
+            constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperMap">
+            <summary>
+            Maps between logger objects and wrapper objects.
+            </summary>
+            <remarks>
+            <para>
+            This class maintains a mapping between <see cref="T:log4net.Core.ILogger"/> objects and
+            <see cref="T:log4net.Core.ILoggerWrapper"/> objects. Use the <see cref="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)"/> method to 
+            lookup the <see cref="T:log4net.Core.ILoggerWrapper"/> for the specified <see cref="T:log4net.Core.ILogger"/>.
+            </para>
+            <para>
+            New wrapper instances are created by the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method. The default behavior is for this method to delegate construction
+            of the wrapper to the <see cref="T:log4net.Core.WrapperCreationHandler"/> delegate supplied
+            to the constructor. This allows specialization of the behavior without
+            requiring subclassing of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.#ctor(log4net.Core.WrapperCreationHandler)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/>
+            </summary>
+            <param name="createWrapperHandler">The handler to use to create the wrapper objects.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/> class with 
+            the specified handler to create the wrapper objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)">
+            <summary>
+            Gets the wrapper object for the specified logger.
+            </summary>
+            <returns>The wrapper object for the specified logger</returns>
+            <remarks>
+            <para>
+            If the logger is null then the corresponding wrapper is null.
+            </para>
+            <para>
+            Looks up the wrapper it it has previously been requested and
+            returns it. If the wrapper has never been requested before then
+            the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/> virtual method is
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)">
+            <summary>
+            Creates the wrapper object for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <returns>The wrapper object for the logger.</returns>
+            <remarks>
+            <para>
+            This implementation uses the <see cref="T:log4net.Core.WrapperCreationHandler"/>
+            passed to the constructor to create the wrapper. This method
+            can be overridden in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.RepositoryShutdown(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Called when a monitored repository shutdown event is received.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down</param>
+            <remarks>
+            <para>
+            This method is called when a <see cref="T:log4net.Repository.ILoggerRepository"/> that this
+            <see cref="T:log4net.Core.WrapperMap"/> is holding loggers for has signaled its shutdown
+            event <see cref="E:log4net.Repository.ILoggerRepository.ShutdownEvent"/>. The default
+            behavior of this method is to release the references to the loggers
+            and their wrappers generated for this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.ILoggerRepository_Shutdown(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for repository shutdown event.
+            </summary>
+            <param name="sender">The sender of the event.</param>
+            <param name="e">The event args.</param>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_repositories">
+            <summary>
+            Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_createWrapperHandler">
+            <summary>
+            The handler to use to create the extension wrapper objects.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_shutdownHandler">
+            <summary>
+            Internal reference to the delegate used to register for repository shutdown events.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.WrapperMap.Repositories">
+            <summary>
+            Gets the map of logger repositories.
+            </summary>
+            <value>
+            Map of logger repositories.
+            </value>
+            <remarks>
+            <para>
+            Gets the hashtable that is keyed on <see cref="T:log4net.Repository.ILoggerRepository"/>. The
+            values are hashtables keyed on <see cref="T:log4net.Core.ILogger"/> with the
+            value being the corresponding <see cref="T:log4net.Core.ILoggerWrapper"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.DateFormatter.IDateFormatter">
+            <summary>
+            Render a <see cref="T:System.DateTime"/> as a string.
+            </summary>
+            <remarks>
+            <para>
+            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
+            instance into a string.
+            </para>
+            <para>
+            The <see cref="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/> method is used to render the
+            date to a text writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the specified date as a string.
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:System.DateTime"/> as a string and write it
+            to the <see cref="T:System.IO.TextWriter"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.AbsoluteTimeDateFormat">
+            <summary>
+            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DateAndTimeDateFormat">
+            <summary>
+            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.Iso8601TimeDateFormat">
+            <summary>
+            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Renders the date into a string. Format is <c>"HH:mm:ss"</c>.
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to render the date
+            into a string using a precision up to the second. This method
+            will be called at most once per second and the result will be
+            reused if it is needed again during the same second.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Renders the date into a string. Format is "HH:mm:ss,fff".
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> method to generate the
+            time string up to the seconds and then appends the current
+            milliseconds. The results from <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> are
+            cached and <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> is called at most once
+            per second.
+            </para>
+            <para>
+            Sub classes should override <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/>
+            rather than <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeToTheSecond">
+            <summary>
+            Last stored time with precision up to the second.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeBuf">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeStrings">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"dd MMM yyyy HH:mm:ss,fff"</c>
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format 
+            <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, 
+            <c>"06 Nov 1994 15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Angelika Schnagl</author>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">
+            <summary>
+            Default constructor.
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats a DateTime in the format <c>"dd MMM yyyy HH:mm:ss"</c>
+            for example, <c>"06 Nov 1994 15:49:37"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_dateTimeFormatInfo">
+            <summary>
+            The format info for the invariant culture.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.Iso8601DateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> as <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> specified as a string: <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats the date specified as a string: <c>"yyyy-MM-dd HH:mm:ss"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.SimpleDateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="T:System.DateTime"/> <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="format">The format string.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> class 
+            with the specified format string.
+            </para>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the date using <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </summary>
+            <param name="dateToFormat">The date to convert to a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the date format string supplied to the constructor to call
+            the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method to format the date.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">
+            <summary>
+            The format string used to format the <see cref="T:System.DateTime"/>.
+            </summary>
+            <remarks>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.DenyAllFilter">
+            <summary>
+            This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>. 
+            </summary>
+            <remarks>
+            <para>
+            You can add this filter to the end of a filter chain to
+            switch from the default "accept all unless instructed otherwise"
+            filtering behavior to a "deny all unless instructed otherwise"
+            behavior.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.FilterSkeleton">
+            <summary>
+            Subclass this type to implement customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should extend this class to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.IFilter">
+            <summary>
+            Implement this interface to provide customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should implement this interface to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the logging event should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The LoggingEvent to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.IFilter.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterSkeleton.m_next">
+            <summary>
+            Points to the next filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
+            <summary>
+            Initialize the filter with the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Typically filter's options become active immediately on set, 
+            however this method must still be called. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            <para>
+            This method is marked <c>abstract</c> and must be implemented
+            in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.FilterSkeleton.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            </summary>
+            <param name="loggingEvent">the LoggingEvent to filter</param>
+            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>
+            <remarks>
+            <para>
+            Ignores the event being logged and just returns
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter
+            chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter
+            should only be used as the last filter in the chain
+            as any further filters will be ignored!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.FilterDecision">
+            <summary>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </summary>
+            <remarks>
+            <para>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Deny">
+            <summary>
+            The log event must be dropped immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Neutral">
+            <summary>
+            This filter is neutral with respect to the log event. 
+            The remaining filters, if any, should be consulted for a final decision.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Accept">
+            <summary>
+            The log event must be logged immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="T:log4net.Filter.LevelMatchFilter">
+            <summary>
+            This is a very simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and
+            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value
+            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.Core.Level"/> of the 
+            <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 
+            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set
+            to <c>true</c>, if it is <c>false</c> then 
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">
+            <summary>
+            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.Accept"/> on a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">
+            <summary>
+            the <see cref="T:log4net.Core.Level"/> to match against
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Tests if the <see cref="T:log4net.Core.Level"/> of the logging event matches that of the filter
+            </summary>
+            <param name="loggingEvent">the event to filter</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the event matches the level of the
+            filter then the result of the function depends on the
+            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then
+            the function will return <see cref="F:log4net.Filter.FilterDecision.Accept"/>, it it is false then it
+            will return <see cref="F:log4net.Filter.FilterDecision.Deny"/>. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">
+            <summary>
+            The <see cref="T:log4net.Core.Level"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            The level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LevelRangeFilter">
+            <summary>
+            This is a simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            that determine the range of priorities that are matched, and
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range
+            of priorities and the <see cref="T:log4net.Core.Level"/> of the <see cref="T:log4net.Core.LoggingEvent"/>, then the 
+            <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"/> 
+            option value is set to <c>true</c>, if it is <c>false</c>
+            then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when matching a <see cref="T:log4net.Core.Level"/>
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">
+            <summary>
+            the minimum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">
+            <summary>
+            the maximum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if the event should be logged.
+            </summary>
+            <param name="loggingEvent">the logging event to check</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the logging event is outside the range
+            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            is returned. If the <see cref="T:log4net.Core.Level"/> is matched then the value of
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">
+            <summary>
+            Set the minimum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The minimum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">
+            <summary>
+            Sets the maximum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The maximum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LoggerMatchFilter">
+            <summary>
+            Simple filter to match a string in the event's logger name.
+            </summary>
+            <remarks>
+            <para>
+            The works very similar to the <see cref="T:log4net.Filter.LevelMatchFilter"/>. It admits two 
+            options <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> and <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>. If the 
+            <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <see cref="T:log4net.Core.LoggingEvent"/> starts 
+            with the value of the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> option, then the 
+            <see cref="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in 
+            case the <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> option value is set to <c>true</c>, 
+            if it is <c>false</c> then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_loggerToMatch">
+            <summary>
+            The logger name string to substring match against the event
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>.
+            If the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> equals the beginning of 
+            the incoming <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> (<see cref="M:String.StartsWith(string)"/>)
+            then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch">
+            <summary>
+            The <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            This filter will attempt to match this value against logger name in
+            the following way. The match will be done against the beginning of the
+            logger name (using <see cref="M:String.StartsWith(string)"/>). The match is
+            case sensitive. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.MdcFilter">
+            <summary>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with layered properties the
+            <see cref="T:log4net.Filter.PropertyFilter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.PropertyFilter">
+            <summary>
+            Simple filter to match a string an event property
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the value for a
+            specific event property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Filter.StringMatchFilter">
+            <summary>
+            Simple filter to match a string in the rendered message
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the rendered message
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">
+            <summary>
+            The string to substring match against the message
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">
+            <summary>
+            A string regex to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">
+            <summary>
+            A regex object to match (generated from m_stringRegexToMatch)
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">
+            <summary>
+            Initialize and precompile the Regex if required
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the message then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">
+            <summary>
+            Sets the static string to match
+            </summary>
+            <remarks>
+            <para>
+            The string that will be substring matched against
+            the rendered message. If the message contains this
+            string then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">
+            <summary>
+            Sets the regular expression to match
+            </summary>
+            <remarks>
+            <para>
+            The regular expression pattern that will be matched against
+            the rendered message. If the message matches this
+            pattern then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.PropertyFilter.m_key">
+            <summary>
+            The key to use to lookup the string from the event properties
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The event property for the <see cref="P:log4net.Filter.PropertyFilter.Key"/> is matched against 
+            the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the property value then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.PropertyFilter.Key">
+            <summary>
+            The key to lookup in the event properties and then match against.
+            </summary>
+            <remarks>
+            <para>
+            The key name to use to lookup in the properties map of the
+            <see cref="T:log4net.Core.LoggingEvent"/>. The match will be performed against 
+            the value of this property if it exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.NdcFilter">
+            <summary>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with named stacks stored in the
+            properties collections the <see cref="T:log4net.Filter.PropertyFilter"/> should 
+            be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.NdcFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Sets the <see cref="P:log4net.Filter.PropertyFilter.Key"/> to <c>"NDC"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AppDomainPatternConverter">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Util.PatternConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            <para>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.#ctor">
+            <summary>
+            Protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternConverter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Evaluate this pattern converter and write the output to a writer.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the appropriate way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next pattern converter in the chains
+            </summary>
+            <param name="patternConverter">the pattern converter that should follow this converter in the chain</param>
+            <returns>the next converter</returns>
+            <remarks>
+            <para>
+            The PatternConverter can merge with its neighbor during this method (or a sub class).
+            Therefore the return value may or may not be the value of the argument passed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the pattern converter to the writer with appropriate formatting
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            This method calls <see cref="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)"/> to allow the subclass to perform
+            appropriate conversion of the pattern converter. If formatting options have
+            been specified via the <see cref="P:log4net.Util.PatternConverter.FormattingInfo"/> then this method will
+            apply those formattings before writing the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SpacePad(System.IO.TextWriter,System.Int32)">
+            <summary>
+            Fast space padding method.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> to which the spaces will be appended.</param>
+            <param name="length">The number of spaces to be padded.</param>
+            <remarks>
+            <para>
+            Fast space padding method.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.m_option">
+            <summary>
+            The option string to the converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionary)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionary"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionaryEnumerator)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionaryEnumerator"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteObject(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Object)">
+            <summary>
+            Write an object to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the Object to a writer. If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the object to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Next">
+            <summary>
+            Get the next pattern converter in the chain
+            </summary>
+            <value>
+            the next pattern converter in the chain
+            </value>
+            <remarks>
+            <para>
+            Get the next pattern converter in the chain
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.FormattingInfo">
+            <summary>
+            Gets or sets the formatting info for this converter
+            </summary>
+            <value>
+            The formatting info for this converter
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the formatting info for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Option">
+            <summary>
+            Gets or sets the option value for this converter
+            </summary>
+            <summary>
+            The option for this converter
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the option value for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+        </member>
+        <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">
+            <summary>
+            Flag indicating if this converter handles exceptions
+            </summary>
+            <remarks>
+            <c>false</c> if this converter handles exceptions
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">
+            <summary>
+            Flag indicating if this converter handles the logging event exception
+            </summary>
+            <value><c>false</c> if this converter handles the logging event exception</value>
+            <remarks>
+            <para>
+            If this converter handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the property should be set to <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this converter does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AppDomainPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetCachePatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetPatternLayoutConverter">
+            <summary>
+            Abstract class that provides access to the current HttpContext (<see cref="P:System.Web.HttpContext.Current"/>) that 
+            derived classes need.
+            </summary>
+            <remarks>
+            This class handles the case when HttpContext.Current is null by writing
+            <see cref="P:log4net.Util.SystemInfo.NotAvailableText"/> to the writer.
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetPatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetCachePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Cache will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetContextPatternConverter">
+            <summary>
+            Converter for items in the <see cref="T:System.Web.HttpContext"/>.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="T:System.Web.HttpContext"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetContextPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net HttpContext item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetRequestPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetRequestPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetSessionPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetSessionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Session will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.DatePatternConverter">
+            <summary>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <remarks>
+            <para>
+            Render the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,yyyy"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Layout.Pattern.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter pattern based on the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ExceptionPatternConverter">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception or the exception property specified
+            by the Option value does not exist then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            <para>
+            Recognized values for the Option parameter are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>Message</description>
+            	</item>
+            	<item>
+            		<description>Source</description>
+            	</item>
+            	<item>
+            		<description>StackTrace</description>
+            	</item>
+            	<item>
+            		<description>TargetSite</description>
+            	</item>
+            	<item>
+            		<description>HelpLink</description>
+            	</item>		
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FileLocationPatternConverter">
+            <summary>
+            Writes the caller location file name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FileLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location file name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FullLocationPatternConverter">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FullLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.IdentityPatternConverter">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.IdentityPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <paramref name="loggingEvent"/> 
+            <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LevelPatternConverter">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LineLocationPatternConverter">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LineLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LoggerPatternConverter">
+            <summary>
+            Converter for logger name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NamedPatternConverter">
+            <summary>
+            Converter to output and truncate <c>'.'</c> separated strings
+            </summary>
+            <remarks>
+            <para>
+            This abstract class supports truncating a <c>'.'</c> separated string
+            to show a specified number of elements from the right hand side.
+            This is used to truncate class names that are fully qualified.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> method to
+            return the fully qualified string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Get the fully qualified string data
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>the fully qualified name</returns>
+            <remarks>
+            <para>
+            Overridden by subclasses to get the fully qualified name before the
+            precision is applied to it.
+            </para>
+            <para>
+            Return the fully qualified <c>'.'</c> (dot/period) separated string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> to the precision
+            specified by the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.NamedPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the NamedPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LoggerPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the logger
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified logger name</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MessagePatternConverter">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MethodLocationPatternConverter">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MethodLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NdcPatternConverter">
+            <summary>
+            Converter to include event NDC
+            </summary>
+            <remarks>
+            <para>
+            Outputs the value of the event property named <c>NDC</c>.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NdcPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event NDC to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            As the thread context stacks are now stored in named event properties
+            this converter simply looks up the value of the <c>NDC</c> property.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PropertyPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">
+            <summary>
+            Converter to output the relative time of the event
+            </summary>
+            <remarks>
+            <para>
+            Converter to output the time of the event relative to the start of the program.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the relative time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the relative time of the event in milliseconds.
+            That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>
+            and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
+            <summary>
+            Helper method to get the time difference between two DateTime objects
+            </summary>
+            <param name="start">start time (in the current local time zone)</param>
+            <param name="end">end time (in the current local time zone)</param>
+            <returns>the time difference in milliseconds</returns>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTraceDetailPatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            </para>
+            </remarks>
+            <author>Adam Davies</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTracePatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            </para>
+            </remarks>
+            <author>Michael Cromwell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the strack frames to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.GetMethodInformation(log4net.Core.MethodItem)">
+            <summary>
+            Returns the Name of the method
+            </summary>
+            <param name="method"></param>
+            <remarks>This method was created, so this class could be used as a base class for StackTraceDetailPatternConverter</remarks>
+            <returns>string</returns>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTracePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTracePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTraceDetailPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTraceDetailPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ThreadPatternConverter">
+            <summary>
+            Converter to include event thread name
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ThreadPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the ThreadName to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.TypeNamePatternConverter">
+            <summary>
+            Pattern converter for the class name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.TypeNamePatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the class
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified type name for the caller location</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UserNamePatternConverter">
+            <summary>
+            Converter to include event user name
+            </summary>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UserNamePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UtcDatePatternConverter">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            Uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> 
+            in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.Pattern.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UtcDatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted
+            to Universal time before it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Layout.Pattern.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.DynamicPatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string that re-evaluates on each call.
+            </summary>
+            <remarks>
+            <para>This class is built on <see cref="T:log4net.Layout.PatternLayout"></see> and provides all the
+            features and capabilities of PatternLayout.  PatternLayout is a 'static' class
+            in that its layout is done once at configuration time.  This class will recreate
+            the layout on each reference.</para>
+            <para>One important difference between PatternLayout and DynamicPatternLayout is the
+            treatment of the Header and Footer parameters in the configuration.  The Header and Footer
+            parameters for DynamicPatternLayout must be syntactically in the form of a PatternString,
+            but should not be marked as type log4net.Util.PatternString.  Doing so causes the
+            pattern to be statically converted at configuration time and causes DynamicPatternLayout
+            to perform the same as PatternLayout.</para>
+            <para>Please see <see cref="T:log4net.Layout.PatternLayout"/> for complete documentation.</para>
+            <example>
+            &lt;layout type="log4net.Layout.DynamicPatternLayout"&gt;
+              &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;
+              &lt;param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;
+            &lt;/layout&gt;
+            </example>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.PatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string.
+            </summary>
+            <remarks>
+            <para>
+            The goal of this class is to <see cref="M:PatternLayout.Format(TextWriter,LoggingEvent)"/> a 
+            <see cref="T:log4net.Core.LoggingEvent"/> as a string. The results
+            depend on the <i>conversion pattern</i>.
+            </para>
+            <para>
+            The conversion pattern is closely related to the conversion
+            pattern of the printf function in C. A conversion pattern is
+            composed of literal text and format control expressions called
+            <i>conversion specifiers</i>.
+            </para>
+            <para>
+            <i>You are free to insert any literal text within the conversion
+            pattern.</i>
+            </para>
+            <para>
+            Each conversion specifier starts with a percent sign (%) and is
+            followed by optional <i>format modifiers</i> and a <i>conversion
+            pattern name</i>. The conversion pattern name specifies the type of
+            data, e.g. logger, level, date, thread name. The format
+            modifiers control such things as field width, padding, left and
+            right justification. The following is a simple example.
+            </para>
+            <para>
+            Let the conversion pattern be <b>"%-5level [%thread]: %message%newline"</b> and assume
+            that the log4net environment was set to use a PatternLayout. Then the
+            statements
+            </para>
+            <code lang="C#">
+            ILog log = LogManager.GetLogger(typeof(TestApp));
+            log.Debug("Message 1");
+            log.Warn("Message 2");   
+            </code>
+            <para>would yield the output</para>
+            <code>
+            DEBUG [main]: Message 1
+            WARN  [main]: Message 2  
+            </code>
+            <para>
+            Note that there is no explicit separator between text and
+            conversion specifiers. The pattern parser knows when it has reached
+            the end of a conversion specifier when it reads a conversion
+            character. In the example above the conversion specifier
+            <b>%-5level</b> means the level of the logging event should be left
+            justified to a width of five characters.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>a</term>
+                    <description>Equivalent to <b>appdomain</b></description>
+                </item>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+            			Used to output the friendly name of the AppDomain where the 
+            			logging event was generated. 
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-cache</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-context</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-request</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-session</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>c</term>
+                    <description>Equivalent to <b>logger</b></description>
+                </item>
+                <item>
+                    <term>C</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>class</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>d</term>
+                    <description>Equivalent to <b>date</b></description>
+                </item>
+                <item>
+            		<term>date</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>exception</term>
+            		<description>
+            			<para>
+            			Used to output the exception passed in with the log message.
+            			</para>
+            			<para>
+            			If an exception object is stored in the logging event
+            			it will be rendered into the pattern output with a
+            			trailing newline.
+            			If there is no exception then nothing will be output
+            			and no trailing newline will be appended.
+            			It is typical to put a newline before the exception
+            			and to have the exception as the last data in the pattern.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>F</term>
+                    <description>Equivalent to <b>file</b></description>
+                </item>
+            	<item>
+            		<term>file</term>
+            		<description>
+            			<para>
+            			Used to output the file name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>identity</term>
+            		<description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>l</term>
+                    <description>Equivalent to <b>location</b></description>
+                </item>
+                <item>
+                    <term>L</term>
+                    <description>Equivalent to <b>line</b></description>
+                </item>
+            	<item>
+            		<term>location</term>
+            		<description>
+            			<para>
+            			Used to output location information of the caller which generated
+            			the logging event.
+            			</para>
+            			<para>
+            			The location information depends on the CLI implementation but
+            			usually consists of the fully qualified name of the calling
+            			method followed by the callers source the file name and line
+            			number between parentheses.
+            			</para>
+            			<para>
+            			The location information can be very useful. However, its
+            			generation is <b>extremely</b> slow. Its use should be avoided
+            			unless execution speed is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>level</term>
+            		<description>
+            			<para>
+            			Used to output the level of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>line</term>
+            		<description>
+            			<para>
+            			Used to output the line number from where the logging request
+            			was issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>logger</term>
+                    <description>
+                        <para>
+            			Used to output the logger of the logging event. The
+            			logger conversion specifier can be optionally followed by
+            			<i>precision specifier</i>, that is a decimal constant in
+            			brackets.
+                        </para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the logger name will be
+            			printed. By default the logger name is printed in full.
+            			</para>
+            			<para>
+            			For example, for the logger name "a.b.c" the pattern
+            			<b>%logger{2}</b> will output "b.c".
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>m</term>
+                    <description>Equivalent to <b>message</b></description>
+                </item>
+                <item>
+                    <term>M</term>
+                    <description>Equivalent to <b>method</b></description>
+                </item>
+            	<item>
+            		<term>message</term>
+            		<description>
+            			<para>
+            			Used to output the application supplied message associated with 
+            			the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>mdc</term>
+            		<description>
+            			<para>
+            			The MDC (old name for the ThreadContext.Properties) is now part of the
+            			combined event properties. This pattern is supported for compatibility
+            			but is equivalent to <b>property</b>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>method</term>
+            		<description>
+            			<para>
+            			Used to output the method name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>n</term>
+                    <description>Equivalent to <b>newline</b></description>
+                </item>
+            	<item>
+            		<term>newline</term>
+            		<description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+            		</description>
+            	</item>
+            	<item>
+            		<term>ndc</term>
+            		<description>
+            			<para>
+            			Used to output the NDC (nested diagnostic context) associated
+            			with the thread that generated the logging event.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>p</term>
+                    <description>Equivalent to <b>level</b></description>
+                </item>
+                <item>
+                    <term>P</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+                <item>
+                    <term>properties</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+            	<item>
+            		<term>property</term>
+            		<description>
+            			<para>
+            			Used to output the an event specific property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are added to events by loggers or appenders. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the event properties</term>
+            					<description>
+            					The event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            					properties are specific to this event only.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+            			
+            		</description>
+            	</item>
+                <item>
+                    <term>r</term>
+                    <description>Equivalent to <b>timestamp</b></description>
+                </item>
+            	<item>
+            		<term>stacktrace</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktrace{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+            			type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>stacktracedetail</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktracedetail{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+                        type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+                <item>
+                    <term>t</term>
+                    <description>Equivalent to <b>thread</b></description>
+                </item>
+            	<item>
+            		<term>timestamp</term>
+            		<description>
+            			<para>
+            			Used to output the number of milliseconds elapsed since the start
+            			of the application until the creation of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>thread</term>
+            		<description>
+            			<para>
+            			Used to output the name of the thread that generated the
+            			logging event. Uses the thread number if no name is available.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>type</term> 
+            		<description>
+            			<para>
+            			Used to output the fully qualified type name of the caller
+            			issuing the logging request. This conversion specifier
+            			can be optionally followed by <i>precision specifier</i>, that
+            			is a decimal constant in brackets.
+            			</para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the class name will be
+            			printed. By default the class name is output in fully qualified form.
+            			</para>
+            			<para>
+            			For example, for the class name "log4net.Layout.PatternLayout", the
+            			pattern <b>%type{1}</b> will output "PatternLayout".
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating the caller class information is
+            			slow. Thus, its use should be avoided unless execution speed is
+            			not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+                </item>
+                <item>
+                    <term>u</term>
+                    <description>Equivalent to <b>identity</b></description>
+                </item>
+            	<item>
+            		<term>username</term>
+            		<description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller WindowsIdentity information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>utcdate</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>w</term>
+                    <description>Equivalent to <b>username</b></description>
+                </item>
+                <item>
+                    <term>x</term>
+                    <description>Equivalent to <b>ndc</b></description>
+                </item>
+                <item>
+                    <term>X</term>
+                    <description>Equivalent to <b>mdc</b></description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            The single letter patterns are deprecated in favor of the 
+            longer more descriptive pattern names.
+            </para>
+            <para>
+            By default the relevant information is output as is. However,
+            with the aid of format modifiers it is possible to change the
+            minimum field width, the maximum field width and justification.
+            </para>
+            <para>
+            The optional format modifier is placed between the percent sign
+            and the conversion pattern name.
+            </para>
+            <para>
+            The first optional format modifier is the <i>left justification
+            flag</i> which is just the minus (-) character. Then comes the
+            optional <i>minimum field width</i> modifier. This is a decimal
+            constant that represents the minimum number of characters to
+            output. If the data item requires fewer characters, it is padded on
+            either the left or the right until the minimum width is
+            reached. The default is to pad on the left (right justify) but you
+            can specify right padding with the left justification flag. The
+            padding character is space. If the data item is larger than the
+            minimum field width, the field is expanded to accommodate the
+            data. The value is never truncated.
+            </para>
+            <para>
+            This behavior can be changed using the <i>maximum field
+            width</i> modifier which is designated by a period followed by a
+            decimal constant. If the data item is longer than the maximum
+            field, then the extra characters are removed from the
+            <i>beginning</i> of the data item and not from the end. For
+            example, it the maximum field width is eight and the data item is
+            ten characters long, then the first two characters of the data item
+            are dropped. This behavior deviates from the printf function in C
+            where truncation is done from the end.
+            </para>
+            <para>
+            Below are various format modifier examples for the logger
+            conversion specifier.
+            </para>
+            <div class="tablediv">
+            	<table class="dtTABLE" cellspacing="0">
+            		<tr>
+            			<th>Format modifier</th>
+            			<th>left justify</th>
+            			<th>minimum width</th>
+            			<th>maximum width</th>
+            			<th>comment</th>
+            		</tr>
+            		<tr>
+            			<td align="center">%20logger</td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is less than 20
+            				characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger 
+            				name is less than 20 characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%.30logger</td>
+            			<td align="center">NA</td>
+            			<td align="center">none</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Truncate from the beginning if the logger 
+            				name is longer than 30 characters.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center"><nobr>%20.30logger</nobr></td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20.30logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            	</table>
+            </div>
+            <para>
+            <b>Note about caller location information.</b><br/>
+            The following patterns <c>%type %file %line %method %location %class %C %F %L %l %M</c> 
+            all generate caller location information.
+            Location information uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            </note>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </note>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Layout.PatternLayout"/>
+            instance using the <see cref="M:AddConverter(string, Type)"/> method.
+            </para>
+            </remarks>
+            <example>
+            This is a more detailed pattern.
+            <code><b>%timestamp [%thread] %level %logger %ndc - %message%newline</b></code>
+            </example>
+            <example>
+            A similar pattern except that the relative time is
+            right padded if less than 6 digits, thread name is right padded if
+            less than 15 characters and truncated if longer and the logger
+            name is left padded if shorter than 30 characters and truncated if
+            longer.
+            <code><b>%-6timestamp [%15.15thread] %-5level %30.30logger %ndc - %message%newline</b></code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="T:log4net.Layout.LayoutSkeleton">
+            <summary>
+            Extend this abstract class to create your own log layout format.
+            </summary>
+            <remarks>
+            <para>
+            This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
+            interface. Most layout objects should extend this class.
+            </para>
+            </remarks>
+            <remarks>
+            <note type="inheritinfo">
+            <para>
+            Subclasses must implement the <see cref="M:Format(TextWriter,LoggingEvent)"/>
+            method.
+            </para>
+            <para>
+            Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default
+            constructor.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.ILayout">
+            <summary>
+            Interface implemented by layout objects
+            </summary>
+            <remarks>
+            <para>
+            An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            as text. The <see cref="M:Format(TextWriter,LoggingEvent)"/> method is called by an
+            appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.
+            </para>
+            <para>
+            The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            text that is appender before any events and after all the events respectively.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text and output to a writer.
+            </para>
+            <para>
+            If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the
+            event to be formatted as a <see cref="T:System.String"/> then the following
+            code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.
+            </para>
+            <code lang="C#">
+            StringWriter writer = new StringWriter();
+            Layout.Format(writer, loggingEvent);
+            string formattedEvent = writer.ToString();
+            </code>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type</value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This is a MIME type e.g. <c>"text/plain"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.IgnoresException">
+            <summary>
+            Flag indicating if this layout handle exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_header">
+            <summary>
+            The header text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
+            <summary>
+            The footer text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <remarks>
+            <para>
+            <c>false</c> if this layout handles exceptions
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
+            <summary>
+            Empty default constructor
+            </summary>
+            <remarks>
+            <para>
+            Empty default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This method must be implemented by the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Convenience method for easily formatting the logging event into a string variable.
+            </summary>
+            <param name="loggingEvent"></param>
+            <remarks>
+            Creates a new StringWriter instance to store the formatted logging event.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type is <c>"text/plain"</c></value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This base class uses the value <c>"text/plain"</c>.
+            To change this value a subclass must override this
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this layout does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DefaultConversionPattern">
+            <summary>
+            Default pattern string for log output. 
+            </summary>
+            <remarks>
+            <para>
+            Default pattern string for log output. 
+            Currently set to the string <b>"%message%newline"</b> 
+            which just prints the application supplied message. 
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DetailConversionPattern">
+            <summary>
+            A detailed conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            A conversion pattern which includes Time, Thread, Logger, and Nested Context.
+            Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+            <remarks>
+            <para>
+            This static map is overridden by the m_converterRegistry instance map
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternLayout only
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+            <remarks>
+            <para>
+            Defines the builtin global rules.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor">
+            <summary>
+            Constructs a PatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            As per the <see cref="T:log4net.Core.IOptionHandler"/> contract the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>
+            method must be called after the properties on this object have been
+            configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a PatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            When using this constructor the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method 
+            need not be called. This may not be the case when using a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">
+            <summary>
+            Create the pattern parser instance
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/> that will format the event</returns>
+            <remarks>
+            <para>
+            Creates the <see cref="T:log4net.Util.PatternParser"/> used to parse the conversion string. Sets the
+            global and instance rules on the <see cref="T:log4net.Util.PatternParser"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Parse the <see cref="T:log4net.Core.LoggingEvent"/> using the patter format
+            specified in the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a named pattern converter to this instance. This
+            converter will be used in the formatting of the event.
+            This method must be called before <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>.
+            </para>
+            <para>
+            The <paramref name="type"/> specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">
+            <summary>
+            The pattern formatting string
+            </summary>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_headerPatternString">
+            <summary>
+            The header PatternString
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_footerPatternString">
+            <summary>
+            The footer PatternString
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor">
+            <summary>
+            Constructs a DynamicPatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a DynamicPatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.ExceptionLayout">
+            <summary>
+            A Layout that renders only the Exception text from the logging event
+            </summary>
+            <remarks>
+            <para>
+            A Layout that renders only the Exception text from the logging event.
+            </para>
+            <para>
+            This Layout should only be used with appenders that utilize multiple
+            layouts (e.g. <see cref="T:log4net.Appender.AdoNetAppender"/>).
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Constructs a ExceptionLayout
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            Part of the <see cref="T:log4net.Core.IOptionHandler"/> component activation
+            framework.
+            </para>
+            <para>
+            This method does nothing as options become effective immediately.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the exception text from the logging event
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Write the exception string to the <see cref="T:System.IO.TextWriter"/>.
+            The exception string is retrieved from <see cref="M:LoggingEvent.GetExceptionString()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.IRawLayout">
+            <summary>
+            Interface for raw layout objects
+            </summary>
+            <remarks>
+            <para>
+            Interface used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            to an object.
+            </para>
+            <para>
+            This interface should not be confused with the
+            <see cref="T:log4net.Layout.ILayout"/> interface. This interface is used in
+            only certain specialized situations where a raw object is
+            required rather than a formatted string. The <see cref="T:log4net.Layout.ILayout"/>
+            is not generally useful than this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.IRawLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Implement this method to create your own layout format.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Layout2RawLayoutAdapter">
+            <summary>
+            Adapts any <see cref="T:log4net.Layout.ILayout"/> to a <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <remarks>
+            <para>
+            Where an <see cref="T:log4net.Layout.IRawLayout"/> is required this adapter
+            allows a <see cref="T:log4net.Layout.ILayout"/> to be specified.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Layout.Layout2RawLayoutAdapter.m_layout">
+            <summary>
+            The layout to adapt
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Construct a new adapter
+            </summary>
+            <param name="layout">the layout to adapt</param>
+            <remarks>
+            <para>
+            Create the adapter for the specified <paramref name="layout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Format the logging event as an object.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Format the logging event as an object.
+            </para>
+            <para>
+            Uses the <see cref="T:log4net.Layout.ILayout"/> object supplied to 
+            the constructor to perform the formatting.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawLayoutConverter">
+            <summary>
+            Type converter for the <see cref="T:log4net.Layout.IRawLayout"/> interface
+            </summary>
+            <remarks>
+            <para>
+            Used to convert objects to the <see cref="T:log4net.Layout.IRawLayout"/> interface.
+            Supports converting from the <see cref="T:log4net.Layout.ILayout"/> interface to
+            the <see cref="T:log4net.Layout.IRawLayout"/> interface using the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertFrom">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from arbitrary types
+            to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to the
+            type supported by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> to the type supported
+            by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the sourceType be converted to an <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <param name="sourceType">the source to be to be converted</param>
+            <returns><c>true</c> if the source type can be converted to <see cref="T:log4net.Layout.IRawLayout"/></returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to a
+            <see cref="T:log4net.Layout.IRawLayout"/>. Only <see cref="T:log4net.Layout.ILayout"/> is supported
+            as the <paramref name="sourceType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the value to a <see cref="T:log4net.Layout.IRawLayout"/> object
+            </summary>
+            <param name="source">the value to convert</param>
+            <returns>the <see cref="T:log4net.Layout.IRawLayout"/> object</returns>
+            <remarks>
+            <para>
+            Convert the <paramref name="source"/> object to a 
+            <see cref="T:log4net.Layout.IRawLayout"/> object. If the <paramref name="source"/> object
+            is a <see cref="T:log4net.Layout.ILayout"/> then the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>
+            is used to adapt between the two interfaces, otherwise an
+            exception is thrown.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawPropertyLayout">
+            <summary>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.#ctor">
+            <summary>
+            Constructs a RawPropertyLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Lookup the property for <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns property value</returns>
+            <remarks>
+            <para>
+            Looks up and returns the object value of the property
+            named <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>. If there is no property defined
+            with than name then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.RawPropertyLayout.Key">
+            <summary>
+            The name of the value to lookup in the LoggingEvent Properties collection.
+            </summary>
+            <value>
+            Value to lookup in the LoggingEvent Properties collection
+            </value>
+            <remarks>
+            <para>
+            String name of the property to lookup in the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in local time. To format the time stamp
+            in universal time use <see cref="T:log4net.Layout.RawUtcTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawUtcTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawUtcTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in universal time. To format the time stamp
+            in local time use <see cref="T:log4net.Layout.RawTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.SimpleLayout">
+            <summary>
+            A very simple layout
+            </summary>
+            <remarks>
+            <para>
+            SimpleLayout consists of the level of the log statement,
+            followed by " - " and then the log message itself. For example,
+            <code>
+            DEBUG - Hello world
+            </code>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.#ctor">
+            <summary>
+            Constructs a SimpleLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a simple formatted output.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Formats the event as the level of the even,
+            followed by " - " and then the log message itself. The
+            output is terminated by a newline.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayout">
+             <summary>
+             Layout that formats the log events as XML elements.
+             </summary>
+             <remarks>
+             <para>
+             The output of the <see cref="T:log4net.Layout.XmlLayout"/> consists of a series of 
+             log4net:event elements. It does not output a complete well-formed XML 
+             file. The output is designed to be included as an <em>external entity</em>
+             in a separate file to form a correct XML file.
+             </para>
+             <para>
+             For example, if <c>abc</c> is the name of the file where
+             the <see cref="T:log4net.Layout.XmlLayout"/> output goes, then a well-formed XML file would 
+             be:
+             </para>
+             <code lang="XML">
+             &lt;?xml version="1.0" ?&gt;
+             
+             &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;
+            
+             &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;
+                 &amp;data;
+             &lt;/log4net:events&gt;
+             </code>
+             <para>
+             This approach enforces the independence of the <see cref="T:log4net.Layout.XmlLayout"/> 
+             and the appender where it is embedded.
+             </para>
+             <para>
+             The <c>version</c> attribute helps components to correctly
+             interpret output generated by <see cref="T:log4net.Layout.XmlLayout"/>. The value of 
+             this attribute should be "1.2" for release 1.2 and later.
+             </para>
+             <para>
+             Alternatively the <c>Header</c> and <c>Footer</c> properties can be
+             configured to output the correct XML header, open tag and close tag.
+             When setting the <c>Header</c> and <c>Footer</c> properties it is essential
+             that the underlying data store not be appendable otherwise the data
+             will become invalid XML.
+             </para>
+             </remarks>
+             <author>Nicko Cadell</author>
+             <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutBase">
+            <summary>
+            Layout that formats the log events as XML elements.
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract class that must be subclassed by an implementation 
+            to conform to a specific schema.
+            </para>
+            <para>
+            Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class
+            with no location info.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="locationInfo" /> parameter determines whether 
+            location information will be output by the layout. If 
+            <paramref name="locationInfo" /> is set to <c>true</c>, then the 
+            file name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the
+            <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed 
+            to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the
+            <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to format
+            the <see cref="T:log4net.Core.LoggingEvent"/> as XML.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">
+            <summary>
+            Flag to indicate if location information should be included in
+            the XML events.
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">
+            <summary>
+            The string to replace invalid chars with
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">
+            <summary>
+            Gets a value indicating whether to include location information in 
+            the XML events.
+            </summary>
+            <value>
+            <c>true</c> if location information should be included in the XML 
+            events; otherwise, <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file 
+            name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an <c>SMTPAppender</c>
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">
+            <summary>
+            The string to replace characters that can not be expressed in XML with.
+            <remarks>
+            <para>
+            Not all characters may be expressed in XML. This property contains the
+            string to replace those that can not with. This defaults to a ?. Set it
+            to the empty string to simply remove offending characters. For more
+            details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets
+            Character replacement will occur in  the log message, the property names 
+            and the property values.
+            </para>
+            </remarks>
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.ContentType">
+            <summary>
+            Gets the content type output by this layout. 
+            </summary>
+            <value>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </value>
+            <remarks>
+            <para>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor">
+            <summary>
+            Constructs an XmlLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XmlLayout.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SmtpAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Builds a cache of the element names
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Override the base class <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method
+            to write the <see cref="T:log4net.Core.LoggingEvent"/> to the <see cref="T:System.Xml.XmlWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayout.m_prefix">
+            <summary>
+            The prefix to use for all generated element names
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Prefix">
+            <summary>
+            The prefix to use for all element names
+            </summary>
+            <remarks>
+            <para>
+            The default prefix is <b>log4net</b>. Set this property
+            to change the prefix. If the prefix is set to an empty string
+            then no prefix will be written.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeMessage">
+            <summary>
+            Set whether or not to base64 encode the message.
+            </summary>
+            <remarks>
+            <para>
+            By default the log message will be written as text to the xml
+            output. This can cause problems when the message contains binary
+            data. By setting this to true the contents of the message will be
+            base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the log message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeProperties">
+            <summary>
+            Set whether or not to base64 encode the property values.
+            </summary>
+            <remarks>
+            <para>
+            By default the properties will be written as text to the xml
+            output. This can cause problems when one or more properties contain
+            binary data. By setting this to true the values of the properties
+            will be base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the property values.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutSchemaLog4j">
+            <summary>
+            Layout that formats the log events as XML elements compatible with the log4j schema
+            </summary>
+            <remarks>
+            <para>
+            Formats the log events according to the http://logging.apache.org/log4j schema.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutSchemaLog4j.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Actually do the writing of the xml
+            </summary>
+            <param name="writer">the writer to use</param>
+            <param name="loggingEvent">the event to write</param>
+            <remarks>
+            <para>
+            Generate XML that is compatible with the log4j schema.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutSchemaLog4j.Version">
+            <summary>
+            The version of the log4j schema to use.
+            </summary>
+            <remarks>
+            <para>
+            Only version 1.2 of the log4j schema is supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.DefaultRenderer">
+            <summary>
+            The default object Renderer.
+            </summary>
+            <remarks>
+            <para>
+            The default renderer supports rendering objects and collections to strings.
+            </para>
+            <para>
+            See the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)"/> method for details of the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ObjectRenderer.IObjectRenderer">
+            <summary>
+            Implement this interface in order to render objects as strings
+            </summary>
+            <remarks>
+            <para>
+            Certain types require special case conversion to
+            string form. This conversion is done by an object renderer.
+            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>
+            interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.IObjectRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a 
+            string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object, TextWriter)"/>
+            method can be used to render these objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)"/>
+            method can be used to render these objects.
+            </para>
+            <para>
+            The default renderer supports rendering objects to strings as follows:
+            </para>
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Rendered String</description>
+            	</listheader>
+            	<item>
+            		<term><c>null</c></term>
+            		<description>
+            		<para>"(null)"</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Array"/></term>
+            		<description>
+            		<para>
+            		For a one dimensional array this is the
+            		array type name, an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace. 
+            		</para>
+            		<para>
+            		For example: <c>int[] {1, 2, 3}</c>.
+            		</para>
+            		<para>
+            		If the array is not one dimensional the 
+            		<c>Array.ToString()</c> is returned.
+            		</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Collections.IEnumerable"/>, <see cref="T:System.Collections.ICollection"/> &amp; <see cref="T:System.Collections.IEnumerator"/></term>
+            		<description>
+            		<para>
+            		Rendered as an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace.
+            		</para>
+            		<para>
+            		For example: <c>{a, b, c}</c>.
+            		</para>
+            		<para>
+            		All collection classes that implement <see cref="T:System.Collections.ICollection"/> its subclasses, 
+            		or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable"/> interface.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term><see cref="T:System.Collections.DictionaryEntry"/></term>
+            		<description>
+            		<para>
+            		Rendered as the key, an equals sign ('='), and the value (using the appropriate
+            		renderer). 
+            		</para>
+            		<para>
+            		For example: <c>key=value</c>.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term>other</term>
+            		<description>
+            		<para><c>Object.ToString()</c></para>
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array,System.IO.TextWriter)">
+            <summary>
+            Render the array argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="array">the array to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            For a one dimensional array this is the
+            array type name, an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>int[] {1, 2, 3}</c>.
+            </para>
+            <para>
+            If the array is not one dimensional the 
+            <c>Array.ToString()</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderEnumerator(log4net.ObjectRenderer.RendererMap,System.Collections.IEnumerator,System.IO.TextWriter)">
+            <summary>
+            Render the enumerator argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="enumerator">the enumerator to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Rendered as an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>{a, b, c}</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderDictionaryEntry(log4net.ObjectRenderer.RendererMap,System.Collections.DictionaryEntry,System.IO.TextWriter)">
+            <summary>
+            Render the DictionaryEntry argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="entry">the DictionaryEntry to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the key, an equals sign ('='), and the value (using the appropriate
+            renderer). For example: <c>key=value</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.RendererMap">
+            <summary>
+            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a mapping between types that require special
+            rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that
+            is used to render them.
+            </para>
+            <para>
+            The <see cref="M:FindAndRender(object)"/> method is used to render an
+            <c>object</c> using the appropriate renderers defined in this map.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <returns>the object rendered as a string</returns>
+            <remarks>
+            <para>
+            This is a convenience method used to render an object to a string.
+            The alternative method <see cref="M:FindAndRender(object,TextWriter)"/>
+            should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Find the appropriate renderer for the type of the
+            <paramref name="obj"/> parameter. This is accomplished by calling the
+            <see cref="M:Get(Type)"/> method. Once a renderer is found, it is
+            applied on the object <paramref name="obj"/> and the result is returned
+            as a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
+            <summary>
+            Gets the renderer for the specified object type
+            </summary>
+            <param name="obj">the object to lookup the renderer for</param>
+            <returns>the renderer for <paramref name="obj"/></returns>
+            <remarks>
+            <param>
+            Gets the renderer for the specified object type.
+            </param>
+            <param>
+            Syntactic sugar method that calls <see cref="M:Get(Type)"/> 
+            with the type of the object parameter.
+            </param>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
+            <summary>
+            Gets the renderer for the specified type
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+            <remarks>
+            <para>
+            Returns the renderer for the specified type.
+            If no specific renderer has been defined the
+            <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">
+            <summary>
+            Internal function to recursively search interfaces
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
+            <summary>
+            Clear the map of renderers
+            </summary>
+            <remarks>
+            <para>
+            Clear the custom renderers defined by using
+            <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>
+            cannot be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>. 
+            </summary>
+            <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>
+            <param name="renderer">the renderer for <paramref name="typeToRender"/></param>
+            <remarks>
+            <para>
+            Register an object renderer for a specific source type.
+            This renderer will be returned from a call to <see cref="M:Get(Type)"/>
+            specifying the same <paramref name="typeToRender"/> as an argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
+            <summary>
+            Get the default renderer instance
+            </summary>
+            <value>the default renderer</value>
+            <remarks>
+            <para>
+            Get the default renderer
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.IPlugin">
+            <summary>
+            Interface implemented by logger repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            Plugins define additional behavior that can be associated
+            with a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The <see cref="T:log4net.Plugin.PluginMap"/> held by the <see cref="P:log4net.Repository.ILoggerRepository.PluginMap"/>
+            property is used to store the plugins for a repository.
+            </para>
+            <para>
+            The <c>log4net.Config.PluginAttribute</c> can be used to
+            attach plugins to repositories created using configuration
+            attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches the plugin to the specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.IPlugin.Name">
+            <summary>
+            Gets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ReadOnly(log4net.Plugin.PluginCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>PluginCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>PluginCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>PluginCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <c>PluginCollection</c>.
+            </summary>
+            <param name="c">The <c>PluginCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.IPlugin[])">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[])">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[],System.Int32)">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the end of the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to be added to the end of the <c>PluginCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clear">
+            <summary>
+            Removes all elements from the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Plugin.PluginCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Contains(log4net.Plugin.IPlugin)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Plugin.IPlugin"/> is in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>PluginCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IndexOf(log4net.Plugin.IPlugin)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Plugin.IPlugin"/>
+            in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to locate in the <c>PluginCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>PluginCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Insert(System.Int32,log4net.Plugin.IPlugin)">
+            <summary>
+            Inserts an element into the <c>PluginCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Plugin.IPlugin"/> from the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the <c>PluginCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Plugin.IPlugin"/> was not found in the <c>PluginCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>PluginCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>PluginCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Plugin.PluginCollection.Enumerator"/> for the entire <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.PluginCollection)">
+            <summary>
+            Adds the elements of another <c>PluginCollection</c> to the current <c>PluginCollection</c>.
+            </summary>
+            <param name="x">The <c>PluginCollection</c> whose elements should be added to the end of the current <c>PluginCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.IPlugin[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> array to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> collection to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the collection.
+            </value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </value>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value><c>true</c> if the collection has a fixed size; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value><c>true</c> if the collection is read-only; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>PluginCollection</c> can contain.
+            </summary>
+            <value>
+            The number of elements the <c>PluginCollection</c> can contain.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Plugin.PluginCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+            <value>
+            The current element in the collection.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.ReadOnlyPluginCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Plugin.PluginMap">
+            <summary>
+            Map of repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            This class is a name keyed map of the plugins that are
+            attached to a repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository that the plugins should be attached to.</param>
+            <remarks>
+            <para>
+            Initialize a new instance of the <see cref="T:log4net.Plugin.PluginMap"/> class with a 
+            repository that the plugins should be attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to add to the map.</param>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Plugin.IPlugin"/> will be attached to the repository when added.
+            </para>
+            <para>
+            If there already exists a plugin with the same name 
+            attached to the repository then the old plugin will
+            be <see cref="M:log4net.Plugin.IPlugin.Shutdown"/> and replaced with
+            the new plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes a <see cref="T:log4net.Plugin.IPlugin"/> from the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the map.</param>
+            <remarks>
+            <para>
+            Remove a specific plugin from this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.Item(System.String)">
+            <summary>
+            Gets a <see cref="T:log4net.Plugin.IPlugin"/> by name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Plugin.IPlugin"/> to lookup.</param>
+            <returns>
+            The <see cref="T:log4net.Plugin.IPlugin"/> from the map with the name specified, or 
+            <c>null</c> if no plugin is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup a plugin by name. If the plugin is not found <c>null</c>
+            will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.AllPlugins">
+            <summary>
+            Gets all possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <value>All possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.</value>
+            <remarks>
+            <para>
+            Get a collection of all the plugins defined in this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginSkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Plugin.IPlugin"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Plugin.IPlugin"/>
+            interface. This base class can be used by implementors
+            of the <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="name">the name of the plugin</param>
+            <remarks>
+            Initializes a new Plugin with the specified name.
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_name">
+            <summary>
+            The name of this plugin.
+            </summary>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_repository">
+            <summary>
+            The repository this plugin is attached to.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.Name">
+            <summary>
+            Gets or sets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            <para>
+            The name of the plugin must not change one the 
+            plugin has been attached to a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.LoggerRepository">
+            <summary>
+            The repository for this plugin
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is attached to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is 
+            attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin">
+            <summary>
+            Plugin that listens for events from the <see cref="T:log4net.Appender.RemotingAppender"/>
+            </summary>
+            <remarks>
+            <para>
+            This plugin publishes an instance of <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/> 
+            on a specified <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/>. This listens for logging events delivered from
+            a remote <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            <para>
+            When an event is received it is relogged within the attached repository
+            as if it had been raised locally.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class.
+            </para>
+            <para>
+            The <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> property must be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor(System.String)">
+            <summary>
+            Construct with sink Uri.
+            </summary>
+            <param name="sinkUri">The name to publish the sink under in the remoting infrastructure. 
+            See <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> for more details.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class
+            with specified name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            When the plugin is shutdown the remote logging
+            sink is disconnected.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.declaringType">
+            <summary>
+            The fully qualified type of the RemoteLoggingServerPlugin class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri">
+            <summary>
+            Gets or sets the URI of this sink.
+            </summary>
+            <value>
+            The URI of this sink.
+            </value>
+            <remarks>
+            <para>
+            This is the name under which the object is marshaled.
+            <see cref="M:RemotingServices.Marshal(MarshalByRefObject,String,Type)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl">
+            <summary>
+            Delivers <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to listen for logging events
+            and deliver them to the local repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository to log to.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl"/> for the
+            specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Logs the events to the repository.
+            </summary>
+            <param name="events">The events to log.</param>
+            <remarks>
+            <para>
+            The events passed are logged to the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.InitializeLifetimeService">
+            <summary>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance.
+            </summary>
+            <returns><c>null</c> to indicate that this instance should live forever.</returns>
+            <remarks>
+            <para>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance. This object should live forever
+            therefore this implementation returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.m_repository">
+            <summary>
+            The underlying <see cref="T:log4net.Repository.ILoggerRepository"/> that events should
+            be logged to.
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">
+            <summary>
+            Default implementation of <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            </summary>
+            <remarks>
+            <para>
+            This default implementation of the <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            interface is used to create the default subclass
+            of the <see cref="T:log4net.Repository.Hierarchy.Logger"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">
+            <summary>
+            Interface abstracts creation of <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances
+            </summary>
+            <remarks>
+            <para>
+            This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to 
+            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.
+            </para>
+            <para>
+            The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)"/> method is called
+            to create a named <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            <para>
+            Implement this interface to create new subclasses of <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl">
+            <summary>
+            Default internal subclass of <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            </summary>
+            <remarks>
+            <para>
+            This subclass has no additional behavior over the
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> class but does allow instances
+            to be created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Logger">
+            <summary>
+            Implementation of <see cref="T:log4net.Core.ILogger"/> used by <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to provide implementation of <see cref="T:log4net.Core.ILogger"/>
+            interface. Applications should use <see cref="T:log4net.LogManager"/> to get
+            logger instances.
+            </para>
+            <para>
+            This is one of the central classes in the log4net implementation. One of the
+            distinctive features of log4net are hierarchical loggers and their
+            evaluation. The <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> organizes the <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            instances into a rooted tree hierarchy.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.Logger"/> class is abstract. Only concrete subclasses of
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> can be created. The <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            is used to create instances of this type for the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">
+            <summary>
+            This constructor created a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance and
+            sets its name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <remarks>
+            <para>
+            This constructor is protected and designed to be used by
+            a subclass that is not abstract.
+            </para>
+            <para>
+            Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> 
+            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default
+            logger creator.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </summary>
+            <param name="newAppender">An appender to add to this logger</param>
+            <remarks>
+            <para>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </para>
+            <para>
+            If <paramref name="newAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">
+            <summary>
+            Look for the appender named as <c>name</c>
+            </summary>
+            <param name="name">The name of the appender to lookup</param>
+            <returns>The appender with the name specified, or <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Returns the named appender, or null if the appender is not found.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">
+            <summary>
+            Remove all previously added appenders from this Logger instance.
+            </summary>
+            <remarks>
+            <para>
+            Remove all previously added appenders from this Logger instance.
+            </para>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the named appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Deliver the <see cref="T:log4net.Core.LoggingEvent"/> to the attached appenders.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Call the appenders in the hierarchy starting at
+            <c>this</c>. If no appenders could be found, emit a
+            warning.
+            </para>
+            <para>
+            This method calls all the appenders inherited from the
+            hierarchy circumventing any evaluation of whether to log or not
+            to log the particular log request.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">
+            <summary>
+            Closes all attached appenders implementing the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Used to ensure that the appenders are correctly shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This is the most generic printing method. This generic form is intended to be used by wrappers
+            </summary>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generates a logging event and delivers it to the attached
+            appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.Core.LoggingEvent)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">
+            <summary>
+            The name of this logger.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">
+            <summary>
+            The assigned level of this logger. 
+            </summary>
+            <remarks>
+            <para>
+            The <c>level</c> variable need not be 
+            assigned a value in which case it is inherited 
+            form the hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">
+            <summary>
+            The parent of this logger.
+            </summary>
+            <remarks>
+            <para>
+            The parent of this logger. 
+            All loggers have at least one ancestor which is the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">
+            <summary>
+            Loggers need to know what Hierarchy they are in.
+            </summary>
+            <remarks>
+            <para>
+            Loggers need to know what Hierarchy they are in.
+            The hierarchy that this logger is a member of is stored
+            here.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderAttachedImpl">
+            <summary>
+            Helper implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">
+            <summary>
+            Flag indicating if child loggers inherit their parents appenders
+            </summary>
+            <remarks>
+            <para>
+            Additivity is set to true by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderLock">
+            <summary>
+            Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl
+            </summary>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">
+            <summary>
+            Gets or sets the parent logger in the hierarchy.
+            </summary>
+            <value>
+            The parent logger in the hierarchy.
+            </value>
+            <remarks>
+            <para>
+            Part of the Composite pattern that makes the hierarchy.
+            The hierarchy is parent linked rather than child linked.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">
+            <summary>
+            Gets or sets a value indicating if child loggers inherit their parent's appenders.
+            </summary>
+            <value>
+            <c>true</c> if child loggers inherit their parent's appenders.
+            </value>
+            <remarks>
+            <para>
+            Additivity is set to <c>true</c> by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.EffectiveLevel">
+            <summary>
+            Gets the effective level for this logger.
+            </summary>
+            <returns>The nearest level in the logger hierarchy.</returns>
+            <remarks>
+            <para>
+            Starting from this logger, searches the logger hierarchy for a
+            non-null level and returns it. Otherwise, returns the level of the
+            root logger.
+            </para>
+            <para>The Logger class is designed so that this method executes as
+            quickly as possible.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>The hierarchy that this logger belongs to.</value>
+            <remarks>
+            <para>
+            This logger must be attached to a single <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.
+            </value>
+            <remarks>
+            <para>
+            The assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> can be <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Appenders">
+            <summary>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <returns>A collection of the appenders in this logger</returns>
+            <remarks>
+            <para>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>. If no appenders 
+            can be found, then a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Name">
+            <summary>
+            Gets the logger name.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl.#ctor(System.String)">
+            <summary>
+            Construct a new Logger
+            </summary>
+            <param name="name">the name of the logger</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl"/> class
+            with the specified name. 
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
+            <summary>
+            Delegate used to handle logger creation event notifications.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> in which the <see cref="T:log4net.Repository.Hierarchy.Logger"/> has been created.</param>
+            <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args that hold the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a
+            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
+            <summary>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument 
+            class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
+            <summary>
+            Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy">
+            <summary>
+            Hierarchical organization of loggers
+            </summary>
+            <remarks>
+            <para>
+            <i>The casual user should not have to deal with this class
+            directly.</i>
+            </para>
+            <para>
+            This class is specialized in retrieving loggers by name and
+            also maintaining the logger hierarchy. Implements the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            The structure of the logger hierarchy is maintained by the
+            <see cref="M:GetLogger(string)"/> method. The hierarchy is such that children
+            link to their parent but parents do not have any references to their
+            children. Moreover, loggers can be instantiated in any order, in
+            particular descendant before ancestor.
+            </para>
+            <para>
+            In case a descendant is created before a particular ancestor,
+            then it creates a provision node for the ancestor and adds itself
+            to the provision node. Other descendants of the same ancestor add
+            themselves to the previously created provision node.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositorySkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.ILoggerRepository">
+            <summary>
+            Interface implemented by logger repositories.
+            </summary>
+            <remarks>
+            <para>
+            This interface is implemented by logger repositories. e.g. 
+            <see cref="N:log4net.Repository.Hierarchy"/>.
+            </para>
+            <para>
+            This interface is used by the <see cref="T:log4net.LogManager"/>
+            to obtain <see cref="T:log4net.ILog"/> interfaces.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
+            <summary>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If the names logger exists it is returned, otherwise
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers as an Array.
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
+            <summary>
+            Returns a named logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Returns a named logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
+            <summary>Shutdown the repository</summary>
+            <remarks>
+            <para>
+            Shutting down a repository will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <see cref="M:Shutdown()"/> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.ConfigurationMessages">
+            <summary>
+            Collection of internal messages captured during the most 
+            recent configuration process.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            <para>
+            These properties can be specified on a repository specific basis.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes the repository with default (empty) properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct the repository using specific properties
+            </summary>
+            <param name="properties">the properties to set for this repository</param>
+            <remarks>
+            <para>
+            Initializes the repository with specified properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
+            <summary>
+            Test if logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the repository
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the repository as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Return a new logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
+            <summary>
+            Shutdown the repository
+            </summary>
+            <remarks>
+            <para>
+            Shutdown the repository. Can be overridden in a subclass.
+            This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>
+            listeners and all attached plugins of the shutdown event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.LoggerRepositorySkeleton.declaringType">
+            <summary>
+            The fully qualified type of the LoggerRepositorySkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Adds an object renderer for a specific class. 
+            </summary>
+            <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>
+            <param name="rendererInstance">The object renderer used to render the object.</param>
+            <remarks>
+            <para>
+            Adds an object renderer for a specific class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository is shutting down
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository is shutting down.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration reset
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has been reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration changed
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">
+            <summary>
+            Raise a configuration changed event on this repository
+            </summary>
+            <param name="e">EventArgs.Empty</param>
+            <remarks>
+            <para>
+            Applications that programmatically change the configuration of the repository should
+            raise this event notification to notify listeners.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes all configured Appenders that implement <see cref="T:log4net.Appender.IFlushable"/>.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed,
+            or <see cref="F:System.Threading.Timeout.Infinite"/> to wait indefinitely.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The string name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of this repository. The name is
+            used to store and lookup the repositories 
+            stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.ConfigurationMessages">
+            <summary>
+            Contains a list of internal messages captures during the 
+            last configuration.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            These properties can be specified on a repository specific basis
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
+            <summary>
+            Basic Configurator interface for repositories
+            </summary>
+            <remarks>
+            <para>
+            Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>
+            with a default <see cref="T:log4net.Appender.IAppender"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the repository using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the repository using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IXmlRepositoryConfigurator">
+            <summary>
+            Configure repository using XML
+            </summary>
+            <remarks>
+            <para>
+            Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the repository using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            The schema for the XML configuration data is defined by
+            the implementation.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct with properties
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with a logger factory
+            </summary>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with properties and a logger factory
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
+            <summary>
+            Test if a logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the hierarchy. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the hierarchy as an Array
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the hierarchy as an Array.
+            The root logger is <b>not</b> included in the returned
+            enumeration.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </summary>
+            <remarks>
+            <para>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
+            <summary>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </summary>
+            <remarks>
+            <para>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <c>Shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
+            <summary>
+            Reset all values contained in this hierarchy instance to their default.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this hierarchy instance to their
+            default.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this hierarchy.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">
+            <summary>
+            Returns all the Appenders that are currently configured
+            </summary>
+            <returns>An array containing all the currently configured appenders</returns>
+            <remarks>
+            <para>
+            Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.
+            All the loggers are searched for appenders. The appenders may also be containers
+            for appenders and these are also searched for additional loggers.
+            </para>
+            <para>
+            The list returned is unordered but does not contain duplicates.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.
+            The appender may also be a container.
+            </summary>
+            <param name="appenderList"></param>
+            <param name="appender"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container
+            </summary>
+            <param name="appenderList"></param>
+            <param name="container"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the log4net system using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">
+            <summary>
+            Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="level">The level to check against.</param>
+            <returns>
+            <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.
+            </returns>
+            <remarks>
+            <para>
+            If this hierarchy has not been configured then this method will
+            always return <c>true</c>.
+            </para>
+            <para>
+            This method will return <c>true</c> if this repository is
+            disabled for <c>level</c> object passed as parameter and
+            <c>false</c> otherwise.
+            </para>
+            <para>
+            See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
+            <summary>
+            Clear all logger definitions from the internal hashtable
+            </summary>
+            <remarks>
+            <para>
+            This call will clear all logger definitions from the internal
+            hashtable. Invoking this method will irrevocably mess up the
+            logger hierarchy.
+            </para>
+            <para>
+            You should <b>really</b> know what you are doing before
+            invoking this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            <paramref name="factory"/>.
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <param name="factory">The factory that will make the new logger instance</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated by the
+            <paramref name="factory"/> parameter and linked with its existing
+            ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Sends a logger creation event to all registered listeners
+            </summary>
+            <param name="logger">The newly created logger</param>
+            <remarks>
+            Raises the logger creation event.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Updates all the parents of the specified logger
+            </summary>
+            <param name="log">The logger to update the parents for</param>
+            <remarks>
+            <para>
+            This method loops through all the <i>potential</i> parents of
+            <paramref name="log"/>. There 3 possible cases:
+            </para>
+            <list type="number">
+            	<item>
+            		<term>No entry for the potential parent of <paramref name="log"/> exists</term>
+            		<description>
+            		We create a ProvisionNode for this potential 
+            		parent and insert <paramref name="log"/> in that provision node.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type Logger for the potential parent.</term>
+            		<description>
+            		The entry is <paramref name="log"/>'s nearest existing parent. We 
+            		update <paramref name="log"/>'s parent field with this entry. We also break from 
+            		he loop because updating our parent's parent is our parent's 
+            		responsibility.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type ProvisionNode for this potential parent.</term>
+            		<description>
+            		We add <paramref name="log"/> to the list of children for this 
+            		potential parent.
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
+            </summary>
+            <param name="pn"></param>
+            <param name="log"></param>
+            <remarks>
+            <para>
+            We update the links for all the children that placed themselves
+            in the provision node 'pn'. The second argument 'log' is a
+            reference for the newly created Logger, parent of all the
+            children in 'pn'.
+            </para>
+            <para>
+            We loop on all the children 'c' in 'pn'.
+            </para>
+            <para>
+            If the child 'c' has been already linked to a child of
+            'log' then there is no need to update 'c'.
+            </para>
+            <para>
+            Otherwise, we set log's parent field to c's parent and set
+            c's parent field to log.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">
+            <summary>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="levelEntry">the level values</param>
+            <remarks>
+            <para>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </para>
+            <para>
+            Supports setting levels via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="propertyEntry">the property value</param>
+            <remarks>
+            <para>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.
+            </para>
+            <para>
+            Supports setting property values via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Hierarchy.declaringType">
+            <summary>
+            The fully qualified type of the Hierarchy class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">
+            <summary>
+            Event used to notify that a logger has been created.
+            </summary>
+            <remarks>
+            <para>
+            Event raised when a logger is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
+            <summary>
+            Has no appender warning been emitted
+            </summary>
+            <remarks>
+            <para>
+            Flag to indicate if we have already issued a warning
+            about not having an appender warning.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
+            <summary>
+            Get the root of this hierarchy
+            </summary>
+            <remarks>
+            <para>
+            Get the root of this hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
+            <summary>
+            Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.
+            </summary>
+            <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>
+            <remarks>
+            <para>
+            The logger factory is used to create logger instances.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">
+            <summary>
+            A class to hold the value, name and display name for a level
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the value, name and display name for a level
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">
+            <summary>
+            Value of the level
+            </summary>
+            <remarks>
+            <para>
+            If the value is not set (defaults to -1) the value will be looked
+            up for the current level with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">
+            <summary>
+            Name of the level
+            </summary>
+            <value>
+            The name of the level
+            </value>
+            <remarks>
+            <para>
+            The name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">
+            <summary>
+            Display name for the level
+            </summary>
+            <value>
+            The display name of the level
+            </value>
+            <remarks>
+            <para>
+            The display name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerKey">
+            <summary>
+            Used internally to accelerate hash table searches.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to improve performance of 
+            string keyed hashtables.
+            </para>
+            <para>
+            The hashcode of the string is cached for reuse.
+            The string is stored as an interned value.
+            When comparing two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> objects for equality 
+            the reference equality of the interned strings is compared.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.#ctor(System.String)">
+            <summary>
+            Construct key with string name
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> class 
+            with the specified name.
+            </para>
+            <para>
+            Stores the hashcode of the string and interns
+            the string key to optimize comparisons.
+            </para>
+            <note>
+            The Compact Framework 1.0 the <see cref="M:System.String.Intern(System.String)"/>
+            method does not work. On the Compact Framework
+            the string keys are not interned nor are they
+            compared by reference.
+            </note>
+            </remarks>
+            <param name="name">The name of the logger.</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.GetHashCode">
+            <summary>
+            Returns a hash code for the current instance.
+            </summary>
+            <returns>A hash code for the current instance.</returns>
+            <remarks>
+            <para>
+            Returns the cached hashcode.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.Equals(System.Object)">
+            <summary>
+            Determines whether two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> instances 
+            are equal.
+            </summary>
+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>.</param>
+            <returns>
+            <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>.
+            </returns>
+            <remarks>
+            <para>
+            Compares the references of the interned strings.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">
+            <summary>
+            Provision nodes are used where no logger instance has been specified
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> instances are used in the 
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> when there is no specified 
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> for that node.
+            </para>
+            <para>
+            A provision node holds a list of child loggers on behalf of
+            a logger that does not exist.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Create a new provision node with child node
+            </summary>
+            <param name="log">A child logger to add to this node.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> class 
+            with the specified child logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.RootLogger">
+            <summary>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> sits at the root of the logger hierarchy tree. 
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> is a regular <see cref="T:log4net.Repository.Hierarchy.Logger"/> except 
+            that it provides several guarantees.
+            </para>
+            <para>
+            First, it cannot be assigned a <c>null</c>
+            level. Second, since the root logger cannot have a parent, the
+            <see cref="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel"/> property always returns the value of the
+            level field without walking the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.Core.Level)">
+            <summary>
+            Construct a <see cref="T:log4net.Repository.Hierarchy.RootLogger"/>
+            </summary>
+            <param name="level">The level to assign to the root logger.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> class with
+            the specified logging level.
+            </para>
+            <para>
+            The root logger names itself as "root". However, the root
+            logger cannot be retrieved by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.RootLogger.declaringType">
+            <summary>
+            The fully qualified type of the RootLogger class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel">
+            <summary>
+            Gets the assigned level value without walking the logger hierarchy.
+            </summary>
+            <value>The assigned level value without walking the logger hierarchy.</value>
+            <remarks>
+            <para>
+            Because the root logger cannot have a parent and its level
+            must not be <c>null</c> this property just returns the
+            value of <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> for the root logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> of the root logger.
+            </value>
+            <remarks>
+            <para>
+            Setting the level of the root logger to a <c>null</c> reference
+            may have catastrophic results. We prevent this here.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator">
+            <summary>
+            Initializes the log4net environment using an XML DOM.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.#ctor(log4net.Repository.Hierarchy.Hierarchy)">
+            <summary>
+            Construct the configurator for a hierarchy
+            </summary>
+            <param name="hierarchy">The hierarchy to build.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator"/> class
+            with the specified <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </summary>
+            <param name="element">The root element to parse.</param>
+            <remarks>
+            <para>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">
+            <summary>
+            Parse appenders by IDREF.
+            </summary>
+            <param name="appenderRef">The appender ref element.</param>
+            <returns>The instance of the appender that the ref refers to.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return 
+            the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">
+            <summary>
+            Parses an appender element.
+            </summary>
+            <param name="appenderElement">The appender element.</param>
+            <returns>The appender instance or <c>null</c> when parsing failed.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return
+            the appender instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLogger(System.Xml.XmlElement)">
+            <summary>
+            Parses a logger element.
+            </summary>
+            <param name="loggerElement">The logger element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRoot(System.Xml.XmlElement)">
+            <summary>
+            Parses the root logger element.
+            </summary>
+            <param name="rootElement">The root element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses the children of a logger element.
+            </summary>
+            <param name="catElement">The category element.</param>
+            <param name="log">The logger instance.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse the child elements of a &lt;logger&gt; element.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement)">
+            <summary>
+            Parses an object renderer.
+            </summary>
+            <param name="element">The renderer element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a renderer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses a level element.
+            </summary>
+            <param name="element">The level element.</param>
+            <param name="log">The logger object to set the level on.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">
+            <summary>
+            Sets a parameter on an object.
+            </summary>
+            <param name="element">The parameter element.</param>
+            <param name="target">The object to set the parameter on.</param>
+            <remarks>
+            The parameter name must correspond to a writable property
+            on the object. The value of the parameter is a string,
+            therefore this function will attempt to set a string
+            property first. If unable to set a string property it
+            will inspect the property and its argument type. It will
+            attempt to call a static method called <c>Parse</c> on the
+            type of the property. This method will take a single
+            string argument and return a value that can be used to
+            set the property.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.HasAttributesOrElements(System.Xml.XmlElement)">
+            <summary>
+            Test if an element has no attributes or child elements
+            </summary>
+            <param name="element">the element to inspect</param>
+            <returns><c>true</c> if the element has any attributes or child elements, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.IsTypeConstructible(System.Type)">
+            <summary>
+            Test if a <see cref="T:System.Type"/> is constructible with <c>Activator.CreateInstance</c>.
+            </summary>
+            <param name="type">the type to inspect</param>
+            <returns><c>true</c> if the type is creatable using a default constructor, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindMethodInfo(System.Type,System.String)">
+            <summary>
+            Look for a method on the <paramref name="targetType"/> that matches the <paramref name="name"/> supplied
+            </summary>
+            <param name="targetType">the type that has the method</param>
+            <param name="name">the name of the method</param>
+            <returns>the method info found</returns>
+            <remarks>
+            <para>
+            The method must be a public instance method on the <paramref name="targetType"/>.
+            The method must be named <paramref name="name"/> or "Add" followed by <paramref name="name"/>.
+            The method must take a single parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string value to a target type.
+            </summary>
+            <param name="type">The type of object to convert the string to.</param>
+            <param name="value">The string value to use as the value of the object.</param>
+            <returns>
+            <para>
+            An object of type <paramref name="type"/> with value <paramref name="value"/> or 
+            <c>null</c> when the conversion could not be performed.
+            </para>
+            </returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement,System.Type,System.Type)">
+            <summary>
+            Creates an object as specified in XML.
+            </summary>
+            <param name="element">The XML element that contains the definition of the object.</param>
+            <param name="defaultTargetType">The object type to use if not explicitly specified.</param>
+            <param name="typeConstraint">The type that the returned object must be or must inherit from.</param>
+            <returns>The object or <c>null</c></returns>
+            <remarks>
+            <para>
+            Parse an XML element and create an object instance based on the configuration
+            data.
+            </para>
+            <para>
+            The type of the instance may be specified in the XML. If not
+            specified then the <paramref name="defaultTargetType"/> is used
+            as the type. However the type is specified it must support the
+            <paramref name="typeConstraint"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_appenderBag">
+            <summary>
+            key: appenderName, value: appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_hierarchy">
+            <summary>
+            The Hierarchy being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlHierarchyConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.ConfigurationChangedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.ConfigurationChangedEventArgs.#ctor(System.Collections.ICollection)">
+            <summary>
+            
+            </summary>
+            <param name="configurationMessages"></param>
+        </member>
+        <member name="P:log4net.Repository.ConfigurationChangedEventArgs.ConfigurationMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryShutdownEventHandler">
+            <summary>
+            Delegate used to handle logger repository shutdown event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository shutdown event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationResetEventHandler">
+            <summary>
+            Delegate used to handle logger repository configuration reset event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration reset.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository configuration reset event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationChangedEventHandler">
+            <summary>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration changed.</param>
+            <param name="e">Empty event arguments.</param>
+            <remarks>
+            <para>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppDomainPatternConverter">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the name of the current AppDomain to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppDomainPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes name of the current AppDomain to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppSettingPatternConverter">
+            <summary>
+            AppSetting pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads appSettings from the application configuration file.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single appSettings value. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all appSettings will be dumped as a list of key value pairs.
+            </para>
+            <para>
+            A typical use is to specify a base directory for log files, e.g.
+            <example>
+            <![CDATA[
+            <log4net>
+               <appender name="MyAppender" type="log4net.Appender.RollingFileAppender">
+                 <file type="log4net.Util.PatternString" value="appsetting{LogDirectory}MyApp.log"/>
+                  ...
+              </appender>
+            </log4net>
+            ]]>
+            </example>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppSettingPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.DatePatternConverter">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The date and time is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date and time passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter">
+            <summary>
+            Write an <see cref="T:System.Environment.SpecialFolder"/> folder path to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an special path environment folder path to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output. <see cref="P:log4net.Util.PatternConverter.Option"/>
+            should be a value in the <see cref="T:System.Environment.SpecialFolder"/> enumeration.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an special path environment folder path to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the special path environment folder path to the output <paramref name="writer"/>.
+            The name of the special path environment folder path to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentFolderPathPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentPatternConverter">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an environment variable to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the environment variable to the output <paramref name="writer"/>.
+            The name of the environment variable to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.IdentityPatternConverter">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current thread identity to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.IdentityPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the current thread identity to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.IdentityPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the IdentityPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">
+            <summary>
+            Pattern converter for literal string instances in the pattern
+            </summary>
+            <remarks>
+            <para>
+            Writes the literal string value specified in the 
+            <see cref="P:log4net.Util.PatternConverter.Option"/> property to 
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next converter in the chain
+            </summary>
+            <param name="pc">The next pattern converter in the chain</param>
+            <returns>The next pattern converter</returns>
+            <remarks>
+            <para>
+            Special case the building of the pattern converter chain
+            for <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> instances. Two adjacent
+            literals in the pattern can be represented by a single combined
+            pattern converter. This implementation detects when a 
+            <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> is added to the chain
+            after this converter and combines its value with this converter's
+            literal value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the literal to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            Override the formatting behavior to ignore the FormattingInfo
+            because we have a literal instead.
+            </para>
+            <para>
+            Writes the value of <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Convert this pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            This method is not used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.NewLinePatternConverter">
+            <summary>
+            Writes a newline to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the system dependent line terminator to the output.
+            This behavior can be overridden by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>:
+            </para>
+            <list type="definition">
+              <listheader>
+                <term>Option Value</term>
+                <description>Output</description>
+              </listheader>
+              <item>
+                <term>DOS</term>
+                <description>DOS or Windows line terminator <c>"\r\n"</c></description>
+              </item>
+              <item>
+                <term>UNIX</term>
+                <description>UNIX line terminator <c>"\n"</c></description>
+              </item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.ProcessIdPatternConverter">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current process ID to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current process ID to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the ProcessIdPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads the thread and global properties.
+            The thread properties take priority over global properties.
+            See <see cref="P:log4net.ThreadContext.Properties"/> for details of the 
+            thread properties. See <see cref="P:log4net.GlobalContext.Properties"/> for
+            details of the global properties.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single property. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all properties will be dumped as a list of key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.PropertyPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.RandomStringPatternConverter">
+            <summary>
+            A Pattern converter that generates a string of random characters
+            </summary>
+            <remarks>
+            <para>
+            The converter generates a string of random characters. By default
+            the string is length 4. This can be changed by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the string value of the length required.
+            </para>
+            <para>
+            The random characters in the string are limited to uppercase letters
+            and numbers only.
+            </para>
+            <para>
+            The random number generator used by this class is not cryptographically secure.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.s_random">
+            <summary>
+            Shared random number generator
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.m_length">
+            <summary>
+            Length of random string to generate. Default length 4.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write a randoim string to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write a randoim string to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the RandomStringPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UserNamePatternConverter">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current threads username to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UserNamePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current threads username to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UserNamePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UserNamePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter">
+            <summary>
+            Write the UTC date time to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UtcDatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date and time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date is in Universal time when it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.BooleanConverter">
+            <summary>
+            Type converter for Boolean.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <c>bool</c> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            <summary>
+            Exception base type for conversion errors.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConverterRegistry">
+            <summary>
+            Register of type converters for specific types.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a registry of type converters used to convert between
+            types.
+            </para>
+            <para>
+            Use the <see cref="M:AddConverter(Type, object)"/> and 
+            <see cref="M:AddConverter(Type, Type)"/> methods to register new converters.
+            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
+            lookup appropriate converters to use.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConverterRegistry"/> class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#cctor">
+            <summary>
+            Static constructor.
+            </summary>
+            <remarks>
+            <para>
+            This constructor defines the intrinsic type converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Object)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converter">The type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter instance for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Type)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converterType">The type of the type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter <see cref="T:System.Type"/> for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="sourceType">The type being converted from.</param>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConverterFromAttribute(System.Type)">
+            <summary>
+            Lookups the type converter to use as specified by the attributes on the 
+            destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.CreateConverterInstance(System.Type)">
+            <summary>
+            Creates the instance of the type converter.
+            </summary>
+            <param name="converterType">The type of the type converter.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            The type specified for the type converter must implement 
+            the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> or <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces 
+            and must have a public default (no argument) constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.declaringType">
+            <summary>
+            The fully qualified type of the ConverterRegistry class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.s_type2converter">
+            <summary>
+            Mapping from <see cref="T:System.Type"/> to type converter.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.EncodingConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an encoding</param>
+            <returns>the encoding</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to 
+            convert the <see cref="T:System.String"/> argument to an <see cref="T:System.Text.Encoding"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertTo">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from a single type to arbitrary types.
+            See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.CanConvertTo(System.Type)">
+            <summary>
+            Returns whether this converter can convert the object to the specified type
+            </summary>
+            <param name="targetType">A Type that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the type supported by this converter can be converted to the
+            <paramref name="targetType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> (which must be of the type supported
+            by this converter) to the <paramref name="targetType"/> specified..
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IPAddressConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an IPAddress</param>
+            <returns>the IPAddress</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Net.IPAddress.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to an <see cref="T:System.Net.IPAddress"/>.
+            If that fails then the string is resolved as a DNS hostname.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.IPAddressConverter.validIpAddressChars">
+            <summary>
+            Valid characters in an IPv4 or IPv6 address string. (Does not support subnets)
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternLayoutConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> 
+            of the <see cref="T:log4net.Layout.PatternLayout"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternLayout</param>
+            <returns>the PatternLayout</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Layout.PatternLayout"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternStringConverter">
+            <summary>
+            Convert between string and <see cref="T:log4net.Util.PatternString"/>
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Util.PatternString"/> type, 
+            and from a <see cref="T:log4net.Util.PatternString"/> type to a string.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Util.PatternString.ConversionPattern"/> 
+            of the <see cref="T:log4net.Util.PatternString"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)">
+            <summary>
+            Can the target type be converted to the type supported by this object
+            </summary>
+            <param name="targetType">A <see cref="T:System.Type"/> that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="targetType"/> is
+            assignable from a <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:PatternString.Format()"/> method to convert the
+            <see cref="T:log4net.Util.PatternString"/> argument to a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            <paramref name="targetType"/>. To check for this condition use the 
+            <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)"/> method.
+            </exception>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternString</param>
+            <returns>the PatternString</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Util.PatternString"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Util.PatternString.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a Type</param>
+            <returns>the Type</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Type"/>.
+            Additional effort is made to locate partially specified types
+            by searching the loaded assemblies.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">
+            <summary>
+            Attribute used to associate a type converter
+            </summary>
+            <remarks>
+            <para>
+            Class and Interface level attribute that specifies a type converter
+            to use with the associated type.
+            </para>
+            <para>
+            To associate a type converter with a target type apply a
+            <c>TypeConverterAttribute</c> to the target type. Specify the
+            type of the type converter on the attribute.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">
+            <summary>
+            The string type name of the type converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">
+            <summary>
+            Create a new type converter attribute for the specified type name
+            </summary>
+            <param name="typeName">The string type name of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">
+            <summary>
+            Create a new type converter attribute for the specified type
+            </summary>
+            <param name="converterType">The type of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">
+            <summary>
+            The string type name of the type converter 
+            </summary>
+            <value>
+            The string type name of the type converter 
+            </value>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.AppenderAttachedImpl">
+            <summary>
+            A straightforward implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This is the default implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/>
+            interface. Implementors of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            should aggregate an instance of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.AppenderAttachedImpl"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvents">The array of events being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.CallAppend(log4net.Appender.IAppender,log4net.Core.LoggingEvent[])">
+            <summary>
+            Calls the DoAppende method on the <see cref="T:log4net.Appender.IAppender"/> with 
+            the <see cref="T:log4net.Core.LoggingEvent"/> objects supplied.
+            </summary>
+            <param name="appender">The appender</param>
+            <param name="loggingEvents">The events</param>
+            <remarks>
+            <para>
+            If the <paramref name="appender"/> supports the <see cref="T:log4net.Appender.IBulkAppender"/>
+            interface then the <paramref name="loggingEvents"/> will be passed 
+            through using that interface. Otherwise the <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the array will be passed one at a time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="newAppender">The appender to add.</param>
+            <remarks>
+            <para>
+            If the appender is already in the list it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup an attached appender by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderList">
+            <summary>
+            List of appenders
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderArray">
+            <summary>
+            Array of appenders, used to cache the m_appenderList
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.declaringType">
+            <summary>
+            The fully qualified type of the AppenderAttachedImpl class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.AppenderAttachedImpl.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <returns>
+            A collection of attached appenders, or <c>null</c> if there
+            are no attached appenders.
+            </returns>
+            <remarks>
+            <para>
+            The read only collection of all currently attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CompositeProperties">
+            <summary>
+            This class aggregates several PropertiesDictionary collections together.
+            </summary>
+            <remarks>
+            <para>
+            Provides a dictionary style lookup over an ordered list of
+            <see cref="T:log4net.Util.PropertiesDictionary"/> collections.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CompositeProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Add(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Add a Properties Dictionary to this composite collection
+            </summary>
+            <param name="properties">the properties to add</param>
+            <remarks>
+            <para>
+            Properties dictionaries added first take precedence over dictionaries added
+            later.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Flatten">
+            <summary>
+            Flatten this composite collection into a single properties dictionary
+            </summary>
+            <returns>the flattened dictionary</returns>
+            <remarks>
+            <para>
+            Reduces the collection of ordered dictionaries to a single dictionary
+            containing the resultant values for the keys.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CompositeProperties.Item(System.String)">
+            <summary>
+            Gets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Looks up the value for the <paramref name="key"/> specified.
+            The <see cref="T:log4net.Util.PropertiesDictionary"/> collections are searched
+            in the order in which they were added to this collection. The value
+            returned is the value held by the first collection that contains
+            the specified key.
+            </para>
+            <para>
+            If none of the collections contain the specified key then
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ContextPropertiesBase">
+            <summary>
+            Base class for Context Properties implementations
+            </summary>
+            <remarks>
+            <para>
+            This class defines a basic property get set accessor
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ConverterInfo">
+            <summary>
+            Wrapper class used to map converter names to converter types
+            </summary>
+            <remarks>
+            <para>
+            Pattern converter info class used during configuration by custom
+            PatternString and PatternLayer converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.#ctor">
+            <summary>
+            default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            
+            </summary>
+            <param name="entry"></param>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Name">
+            <summary>
+            Gets or sets the name of the conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            The name of the pattern in the format string
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Type">
+            <summary>
+            Gets or sets the type of the converter
+            </summary>
+            <remarks>
+            <para>
+            The value specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.CountingQuietTextWriter">
+            <summary>
+            Subclass of <see cref="T:log4net.Util.QuietTextWriter"/> that maintains a count of 
+            the number of bytes written.
+            </summary>
+            <remarks>
+            <para>
+            This writer counts the number of bytes written.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.QuietTextWriter">
+            <summary>
+            <see cref="T:System.IO.TextWriter"/> that does not leak exceptions
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Util.QuietTextWriter"/> does not throw exceptions when things go wrong. 
+            Instead, it delegates error handling to its <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TextWriterAdapter">
+            <summary>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.TextWriterAdapter.m_writer">
+            <summary>
+            The writer to forward messages to
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Close">
+            <summary>
+            Closes the writer and releases any system resources associated with the writer
+            </summary>
+            <remarks>
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">
+            <summary>
+            Dispose this writer
+            </summary>
+            <param name="disposing">flag indicating if we are being disposed</param>
+            <remarks>
+            <para>
+            Dispose this writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Flush">
+            <summary>
+            Flushes any buffered output
+            </summary>
+            <remarks>
+            <para>
+            Clears all buffers for the writer and causes any buffered data to be written 
+            to the underlying device
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">
+            <summary>
+            Writes a character to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a character to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a character buffer to the wrapped TextWriter
+            </summary>
+            <param name="buffer">the data buffer</param>
+            <param name="index">the start index</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a character buffer to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">
+            <summary>
+            Writes a string to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a string to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Writer">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.IO.TextWriter"/>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Encoding">
+            <summary>
+            The Encoding in which the output is written
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>
+            </value>
+            <remarks>
+            <para>
+            The Encoding in which the output is written
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">
+            <summary>
+            Gets an object that controls formatting
+            </summary>
+            <value>
+            The format provider
+            </value>
+            <remarks>
+            <para>
+            Gets an object that controls formatting
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.NewLine">
+            <summary>
+            Gets or sets the line terminator string used by the TextWriter
+            </summary>
+            <value>
+            The line terminator to use
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the line terminator string used by the TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <param name="errorHandler">the error handler to report error to</param>
+            <remarks>
+            <para>
+            Create a new QuietTextWriter using a writer and error handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Writes a character to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a buffer to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output.
+            </summary>
+            <param name="value">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Writes a string to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Close">
+            <summary>
+            Closes the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_errorHandler">
+            <summary>
+            The error handler instance to pass all errors to
+            </summary>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_closed">
+            <summary>
+            Flag to indicate if this writer is closed
+            </summary>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.ErrorHandler">
+            <summary>
+            Gets or sets the error handler that all errors are passed to.
+            </summary>
+            <value>
+            The error handler that all errors are passed to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the error handler that all errors are passed to.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.Closed">
+            <summary>
+            Gets a value indicating whether this writer is closed.
+            </summary>
+            <value>
+            <c>true</c> if this writer is closed, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets a value indicating whether this writer is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to actually write to.</param>
+            <param name="errorHandler">The <see cref="T:log4net.Core.IErrorHandler"/> to report errors to.</param>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.CountingQuietTextWriter"/> class 
+            with the specified <see cref="T:System.IO.TextWriter"/> and <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output and counts the number of bytes written.
+            </summary>
+            <param name="str">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.CountingQuietTextWriter.m_countBytes">
+            <summary>
+            Total number of bytes written.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.CountingQuietTextWriter.Count">
+            <summary>
+            Gets or sets the total number of bytes written.
+            </summary>
+            <value>
+            The total number of bytes written.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the total number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CyclicBuffer">
+            <summary>
+            A fixed size rolling buffer of logging events.
+            </summary>
+            <remarks>
+            <para>
+            An array backed fixed size leaky bucket.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="maxSize">The maximum number of logging events in the buffer.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with 
+            the specified maximum number of buffered logging events.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Appends a <paramref name="loggingEvent"/> to the buffer.
+            </summary>
+            <param name="loggingEvent">The event to append to the buffer.</param>
+            <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Append an event to the buffer. If the buffer still contains free space then
+            <c>null</c> is returned. If the buffer is full then an event will be dropped
+            to make space for the new event, the event dropped is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopOldest">
+            <summary>
+            Get and remove the oldest event in the buffer.
+            </summary>
+            <returns>The oldest logging event in the buffer</returns>
+            <remarks>
+            <para>
+            Gets the oldest (first) logging event in the buffer and removes it 
+            from the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopAll">
+            <summary>
+            Pops all the logging events from the buffer into an array.
+            </summary>
+            <returns>An array of all the logging events in the buffer.</returns>
+            <remarks>
+            <para>
+            Get all the events in the buffer and clear the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Clear">
+            <summary>
+            Clear the buffer
+            </summary>
+            <remarks>
+            <para>
+            Clear the buffer of all events. The events in the buffer are lost.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">
+            <summary>
+            Gets the <paramref name="i"/>th oldest event currently in the buffer.
+            </summary>
+            <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>
+            <remarks>
+            <para>
+            If <paramref name="i"/> is outside the range 0 to the number of events
+            currently in the buffer, then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.MaxSize">
+            <summary>
+            Gets the maximum size of the buffer.
+            </summary>
+            <value>The maximum size of the buffer.</value>
+            <remarks>
+            <para>
+            Gets the maximum size of the buffer
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Length">
+            <summary>
+            Gets the number of logging events in the buffer.
+            </summary>
+            <value>The number of logging events in the buffer.</value>
+            <remarks>
+            <para>
+            This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>
+            (inclusive).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyCollection">
+            <summary>
+            An always empty <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.ICollection"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyCollection"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.EmptyCollection.s_instance">
+            <summary>
+            The singleton instance of the empty collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Instance">
+            <summary>
+            Gets the singleton instance of the empty collection.
+            </summary>
+            <returns>The singleton instance of the empty collection.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the empty collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyCollection.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyCollection.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyDictionary">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionary"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyDictionary"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Add(System.Object,System.Object)">
+            <summary>
+            Adds an element with the provided key and value to the 
+            <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>
+            <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>
+            <remarks>
+            <para>
+            As the collection is empty no new values can be added. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Clear">
+            <summary>
+            Removes all elements from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Contains(System.Object)">
+            <summary>
+            Determines whether the <see cref="T:log4net.Util.EmptyDictionary"/> contains an element 
+            with the specified key.
+            </summary>
+            <param name="key">The key to locate in the <see cref="T:log4net.Util.EmptyDictionary"/>.</param>
+            <returns><c>false</c></returns>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="M:log4net.Util.EmptyDictionary.Contains(System.Object)"/> method always returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Remove(System.Object)">
+            <summary>
+            Removes the element with the specified key from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The key of the element to remove.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="F:log4net.Util.EmptyDictionary.s_instance">
+            <summary>
+            The singleton instance of the empty dictionary.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <b>true</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyDictionary.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyDictionary.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> has a fixed size.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsFixedSize"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> is read-only.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsReadOnly"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Keys">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Values">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Item(System.Object)">
+            <summary>
+            Gets or sets the element with the specified key.
+            </summary>
+            <param name="key">The key of the element to get or set.</param>
+            <value><c>null</c></value>
+            <remarks>
+            <para>
+            As the collection is empty no values can be looked up or stored. 
+            If the index getter is called then <c>null</c> is returned.
+            A <see cref="T:System.InvalidOperationException"/> is thrown if the setter is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="T:log4net.Util.FormattingInfo">
+            <summary>
+            Contain the information obtained when parsing formatting modifiers 
+            in conversion modifiers.
+            </summary>
+            <remarks>
+            <para>
+            Holds the formatting information extracted from the format string by
+            the <see cref="T:log4net.Util.PatternParser"/>. This is used by the <see cref="T:log4net.Util.PatternConverter"/>
+            objects when rendering the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor">
+            <summary>
+            Defaut Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor(System.Int32,System.Int32,System.Boolean)">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class
+            with the specified parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Min">
+            <summary>
+            Gets or sets the minimum value.
+            </summary>
+            <value>
+            The minimum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the minimum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Max">
+            <summary>
+            Gets or sets the maximum value.
+            </summary>
+            <value>
+            The maximum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the maximum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.LeftAlign">
+            <summary>
+            Gets or sets a flag indicating whether left align is enabled
+            or not.
+            </summary>
+            <value>
+            A flag indicating whether left align is enabled or not.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a flag indicating whether left align is enabled or not.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.GlobalContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.GlobalContext"/>
+            </summary>
+            <remarks>
+            <para>
+            This class implements a properties collection that is thread safe and supports both
+            storing properties and capturing a read only copy of the current propertied.
+            </para>
+            <para>
+            This class is optimized to the scenario where the properties are read frequently
+            and are modified infrequently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_readOnlyProperties">
+            <summary>
+            The read only copy of the properties.
+            </summary>
+            <remarks>
+            <para>
+            This variable is declared <c>volatile</c> to prevent the compiler and JIT from
+            reordering reads and writes of this thread performed on different threads.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_syncRoot">
+            <summary>
+            Lock object used to synchronize updates within this instance
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.GlobalContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property from the global context
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Removing an entry from the global context properties is relatively expensive compared
+            with reading a value. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Clear">
+            <summary>
+            Clear the global context properties
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.GetReadOnlyProperties">
+            <summary>
+            Get a readonly immutable copy of the properties
+            </summary>
+            <returns>the current global context properties</returns>
+            <remarks>
+            <para>
+            This implementation is fast because the GlobalContextProperties class
+            stores a readonly copy of the properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.GlobalContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Reading the value for a key is faster than setting the value.
+            When the value is written a new read only copy of 
+            the properties is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ILogExtensions">
+            <summary>
+            The static class ILogExtensions contains a set of widely used
+            methods that ease the interaction with the ILog interface implementations.
+            </summary>
+            <remarks>
+            <para>
+            This class contains methods for logging at different levels and checks the
+            properties for determining if those logging levels are enabled in the current
+            configuration.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            using log4net.Util;
+            
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.InfoExt("Application Start");
+            log.DebugExt("This is a debug message");
+            </code>
+            </example>
+        </member>
+        <member name="F:log4net.Util.ILogExtensions.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="T:log4net.Util.LevelMapping">
+            <summary>
+            Manages a mapping from levels to <see cref="T:log4net.Util.LevelMappingEntry"/>
+            </summary>
+            <remarks>
+            <para>
+            Manages an ordered mapping from <see cref="T:log4net.Core.Level"/> instances 
+            to <see cref="T:log4net.Util.LevelMappingEntry"/> subclasses.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialise a new instance of <see cref="T:log4net.Util.LevelMapping"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Add(log4net.Util.LevelMappingEntry)">
+            <summary>
+            Add a <see cref="T:log4net.Util.LevelMappingEntry"/> to this mapping
+            </summary>
+            <param name="entry">the entry to add</param>
+            <remarks>
+            <para>
+            If a <see cref="T:log4net.Util.LevelMappingEntry"/> has previously been added
+            for the same <see cref="T:log4net.Core.Level"/> then that entry will be 
+            overwritten.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Lookup(log4net.Core.Level)">
+            <summary>
+            Lookup the mapping for the specified level
+            </summary>
+            <param name="level">the level to lookup</param>
+            <returns>the <see cref="T:log4net.Util.LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
+            <remarks>
+            <para>
+            Lookup the value for the specified level. Finds the nearest
+            mapping value for the level that is equal to or less than the
+            <paramref name="level"/> specified.
+            </para>
+            <para>
+            If no mapping could be found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.ActivateOptions">
+            <summary>
+            Initialize options
+            </summary>
+            <remarks>
+            <para>
+            Caches the sorted list of <see cref="T:log4net.Util.LevelMappingEntry"/> in an array
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            <para>
+            This class stores its properties in a slot on the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> named
+            <c>log4net.Util.LogicalThreadContextProperties</c>.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.m_disabled">
+            <summary>
+            Flag used to disable this context if we don't have permission to access the CallContext.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the value for the specified <paramref name="key"/> from the context.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Clear">
+            <summary>
+            Clear all the context properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all the context properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the PropertiesDictionary stored in the LocalDataStoreSlot for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doings so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetLogicalProperties">
+            <summary>
+            Gets the call context get data.
+            </summary>
+            <returns>The peroperties dictionary stored in the call context</returns>
+            <remarks>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.GetData(System.String)"/> has a
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.SetLogicalProperties(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Sets the call context data.
+            </summary>
+            <param name="properties">The properties.</param>
+            <remarks>
+            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
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.declaringType">
+            <summary>
+            The fully qualified type of the LogicalThreadContextProperties class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Get or set the property value for the <paramref name="key"/> specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TwoArgAction`2">
+            <summary>
+            Delegate type used for LogicalThreadContextStack's callbacks.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_propertyKey">
+            <summary>
+            The name of this <see cref="T:log4net.Util.LogicalThreadContextStack"/> within the
+            <see cref="T:log4net.Util.LogicalThreadContextProperties"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_registerNew">
+            <summary>
+            The callback used to let the <see cref="T:log4net.Util.LogicalThreadContextStacks"/> register a
+            new instance of a <see cref="T:log4net.Util.LogicalThreadContextStack"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.#ctor(System.String,log4net.Util.TwoArgAction{System.String,log4net.Util.LogicalThreadContextStack})">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this thread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.LogicalThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.LogicalThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_logicalThreadContextStack">
+            <summary>
+            The outer LogicalThreadContextStack.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.#ctor(log4net.Util.LogicalThreadContextStack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="logicalThreadContextStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStacks.#ctor(log4net.Util.LogicalThreadContextProperties)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventHandler">
+            <summary>
+            
+            </summary>
+            <param name="source"></param>
+            <param name="e"></param>
+        </member>
+        <member name="T:log4net.Util.LogLog">
+            <summary>
+            Outputs log statements from within the log4net assembly.
+            </summary>
+            <remarks>
+            <para>
+            Log4net components cannot make log4net logging calls. However, it is
+            sometimes useful for the user to learn about what log4net is
+            doing.
+            </para>
+            <para>
+            All log4net internal debug calls go to the standard output stream
+            whereas internal error messages are sent to the standard error output 
+            stream.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.LogLog.ToString">
+            <summary>
+            Formats Prefix, Source, and Message in the same format as the value
+            sent to Console.Out and Trace.Write.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.LogLog.#ctor(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogLog"/> class. 
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.#cctor">
+            <summary>
+            Static constructor that initializes logging by reading 
+            settings from the application configuration file.
+            </summary>
+            <remarks>
+            <para>
+            The <c>log4net.Internal.Debug</c> application setting
+            controls internal debugging. This setting should be set
+            to <c>true</c> to enable debugging.
+            </para>
+            <para>
+            The <c>log4net.Internal.Quiet</c> application setting
+            suppresses all internal logging including error messages. 
+            This setting should be set to <c>true</c> to enable message
+            suppression.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.OnLogReceived(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Raises the LogReceived event when an internal messages is received.
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source"></param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal error messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitOutLine(System.String)">
+            <summary>
+            Writes output to the standard output stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Out and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitErrorLine(System.String)">
+            <summary>
+            Writes output to the standard error stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Error and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_debugEnabled">
+            <summary>
+             Default debug level
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_quietMode">
+            <summary>
+            In quietMode not even errors generate any output.
+            </summary>
+        </member>
+        <member name="E:log4net.Util.LogLog.LogReceived">
+            <summary>
+            The event raised when an internal message has been received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Source">
+            <summary>
+            The Type that generated the internal message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStamp">
+            <summary>
+            The DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStampUtc">
+            <summary>
+            The UTC DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Prefix">
+            <summary>
+            A string indicating the severity of the internal message.
+            </summary>
+            <remarks>
+            "log4net: ", 
+            "log4net:ERROR ", 
+            "log4net:WARN "
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.Message">
+            <summary>
+            The internal log message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Exception">
+            <summary>
+            The Exception related to the message.
+            </summary>
+            <remarks>
+            Optional. Will be null if no Exception was passed.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.InternalDebugging">
+            <summary>
+            Gets or sets a value indicating whether log4net internal logging
+            is enabled or disabled.
+            </summary>
+            <value>
+            <c>true</c> if log4net internal logging is enabled, otherwise 
+            <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c>, internal debug level logging will be 
+            displayed.
+            </para>
+            <para>
+            This value can be set by setting the application setting 
+            <c>log4net.Internal.Debug</c> in the application configuration
+            file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. debugging is
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            The following example enables internal debugging using the 
+            application configuration file :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Debug" value="true" />
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.QuietMode">
+            <summary>
+            Gets or sets a value indicating whether log4net should generate no output
+            from internal logging, not even for errors. 
+            </summary>
+            <value>
+            <c>true</c> if log4net should generate no output at all from internal 
+            logging, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c> will cause internal logging at all levels to be 
+            suppressed. This means that no warning or error reports will be logged. 
+            This option overrides the <see cref="P:log4net.Util.LogLog.InternalDebugging"/> setting and 
+            disables all debug also.
+            </para>
+            <para>This value can be set by setting the application setting
+            <c>log4net.Internal.Quiet</c> in the application configuration file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. internal logging is not
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            The following example disables internal logging using the 
+            application configuration file :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Quiet" value="true"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.EmitInternalMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsDebugEnabled">
+            <summary>
+            Test if LogLog.Debug is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Debug is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Debug is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsWarnEnabled">
+            <summary>
+            Test if LogLog.Warn is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Warn is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Warn is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsErrorEnabled">
+            <summary>
+            Test if LogLog.Error is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Error is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Error is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogLog.LogReceivedAdapter">
+            <summary>
+            Subscribes to the LogLog.LogReceived event and stores messages
+            to the supplied IList instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.#ctor(System.Collections.IList)">
+            <summary>
+            
+            </summary>
+            <param name="items"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.Dispose">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.LogReceivedAdapter.Items">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogReceivedEventArgs.#ctor(log4net.Util.LogLog)">
+            <summary>
+            
+            </summary>
+            <param name="loglog"></param>
+        </member>
+        <member name="P:log4net.Util.LogReceivedEventArgs.LogLog">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.NativeError">
+            <summary>
+            Represents a native error code and message.
+            </summary>
+            <remarks>
+            <para>
+            Represents a Win32 platform native error.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NativeError.#ctor(System.Int32,System.String)">
+            <summary>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </summary>
+            <param name="number">The number of the native error.</param>
+            <param name="message">The message of the native error.</param>
+            <remarks>
+            <para>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetLastError">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class for the last Windows error.
+            </summary>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the last windows error.
+            </returns>
+            <remarks>
+            <para>
+            The message for the <see cref="M:System.Runtime.InteropServices.Marshal.GetLastWin32Error"/> error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetError(System.Int32)">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class.
+            </summary>
+            <param name="number">the error number for the native error</param>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the specified 
+            error number.
+            </returns>
+            <remarks>
+            <para>
+            The message for the specified error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetErrorMessage(System.Int32)">
+            <summary>
+            Retrieves the message corresponding with a Win32 message identifier.
+            </summary>
+            <param name="messageId">Message identifier for the requested message.</param>
+            <returns>
+            The message corresponding with the specified message identifier.
+            </returns>
+            <remarks>
+            <para>
+            The message will be searched for in system message-table resource(s)
+            using the native <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.ToString">
+            <summary>
+            Return error information string
+            </summary>
+            <returns>error information string</returns>
+            <remarks>
+            <para>
+            Return error information string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.FormatMessage(System.Int32,System.IntPtr@,System.Int32,System.Int32,System.String@,System.Int32,System.IntPtr)">
+            <summary>
+            Formats a message string.
+            </summary>
+            <param name="dwFlags">Formatting options, and how to interpret the <paramref name="lpSource" /> parameter.</param>
+            <param name="lpSource">Location of the message definition.</param>
+            <param name="dwMessageId">Message identifier for the requested message.</param>
+            <param name="dwLanguageId">Language identifier for the requested message.</param>
+            <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>
+            <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>
+            <param name="Arguments">Pointer to an array of values that are used as insert values in the formatted message.</param>
+            <remarks>
+            <para>
+            The function requires a message definition as input. The message definition can come from a 
+            buffer passed into the function. It can come from a message table resource in an 
+            already-loaded module. Or the caller can ask the function to search the system's message 
+            table resource(s) for the message definition. The function finds the message definition 
+            in a message table resource based on a message identifier and a language identifier. 
+            The function copies the formatted message text to an output buffer, processing any embedded 
+            insert sequences if requested.
+            </para>
+            <para>
+            To prevent the usage of unsafe code, this stub does not support inserting values in the formatted message.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is the number of TCHARs stored in the output 
+            buffer, excluding the terminating null character.
+            </para>
+            <para>
+            If the function fails, the return value is zero. To get extended error information, 
+            call <see cref="M:Marshal.GetLastWin32Error()" />.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Util.NativeError.Number">
+            <summary>
+            Gets the number of the native error.
+            </summary>
+            <value>
+            The number of the native error.
+            </value>
+            <remarks>
+            <para>
+            Gets the number of the native error.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NativeError.Message">
+            <summary>
+            Gets the message of the native error.
+            </summary>
+            <value>
+            The message of the native error.
+            </value>
+            <remarks>
+            <para>
+            </para>
+            Gets the message of the native error.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.NullDictionaryEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionaryEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionaryEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance.
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullDictionaryEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullDictionaryEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullDictionaryEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Key">
+            <summary>
+            Gets the current key from the enumerator.
+            </summary>
+            <remarks>
+            Throws an exception because the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>
+            never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Key"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Value">
+            <summary>
+            Gets the current value from the enumerator.
+            </summary>
+            <value>The current value from the enumerator.</value>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Value"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Entry">
+            <summary>
+            Gets the current entry from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current entry.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Entry"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Instance">
+            <summary>
+            Get the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullSecurityContext">
+            <summary>
+            A SecurityContext used when a SecurityContext is not required
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Util.NullSecurityContext"/> is a no-op implementation of the
+            <see cref="T:log4net.Core.SecurityContext"/> base class. It is used where a <see cref="T:log4net.Core.SecurityContext"/>
+            is required but one has not been provided.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.NullSecurityContext.Instance">
+            <summary>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            <para>
+            Private constructor for singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns><c>null</c></returns>
+            <remarks>
+            <para>
+            No impersonation is done and <c>null</c> is always returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OnlyOnceErrorHandler">
+            <summary>
+            Implements log4net's default error handling policy which consists 
+            of emitting a message for the first error in an appender and 
+            ignoring all subsequent errors.
+            </summary>
+            <remarks>
+            <para>
+            The error message is processed using the LogLog sub-system by default.
+            </para>
+            <para>
+            This policy aims at protecting an otherwise working application
+            from being flooded with error messages when logging fails.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="prefix">The prefix to use for each message.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class
+            with the specified prefix.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Reset">
+            <summary>
+            Reset the error handler back to its initial disabled state.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log the very first error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            Sends the error information to <see cref="T:log4net.Util.LogLog"/>'s Error method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">
+            <summary>
+            Log an error
+            </summary>
+            <param name="message">The error message.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_enabledDateUtc">
+            <summary>
+            The UTC date the error was recorded.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">
+            <summary>
+            Flag to indicate if it is the first error
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_message">
+            <summary>
+            The message recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_exception">
+            <summary>
+            The exception recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_errorCode">
+            <summary>
+            The error code recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">
+            <summary>
+            String to prefix each message with
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.declaringType">
+            <summary>
+            The fully qualified type of the OnlyOnceErrorHandler class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">
+            <summary>
+            Is error logging enabled
+            </summary>
+            <remarks>
+            <para>
+            Is error logging enabled. Logging is only enabled for the
+            first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDate">
+            <summary>
+            The date the first error that trigged this error handler occurred, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDateUtc">
+            <summary>
+            The UTC date the first error that trigged this error handler occured, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorMessage">
+            <summary>
+            The message from the first error that trigged this error handler.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.Exception">
+            <summary>
+            The exception from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            May be <see langword="null" />.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorCode">
+            <summary>
+            The error code from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            Defaults to <see cref="F:log4net.Core.ErrorCode.GenericFailure"/>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OptionConverter">
+            <summary>
+            A convenience class to convert property values to specific types.
+            </summary>
+            <remarks>
+            <para>
+            Utility functions for converting types and parsing values.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.OptionConverter"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToBoolean(System.String,System.Boolean)">
+            <summary>
+            Converts a string to a <see cref="T:System.Boolean"/> value.
+            </summary>
+            <param name="argValue">String to convert.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Boolean"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            If <paramref name="argValue"/> is "true", then <c>true</c> is returned. 
+            If <paramref name="argValue"/> is "false", then <c>false</c> is returned. 
+            Otherwise, <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToFileSize(System.String,System.Int64)">
+            <summary>
+            Parses a file size into a number.
+            </summary>
+            <param name="argValue">String to parse.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Int64"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            Parses a file size of the form: number[KB|MB|GB] into a
+            long value. It is scaled with the appropriate multiplier.
+            </para>
+            <para>
+            <paramref name="defaultValue"/> is returned when <paramref name="argValue"/>
+            cannot be converted to a <see cref="T:System.Int64"/> value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string to an object.
+            </summary>
+            <param name="target">The target type to convert to.</param>
+            <param name="txt">The string to convert to an object.</param>
+            <returns>
+            The object converted from a string or <c>null</c> when the 
+            conversion failed.
+            </returns>
+            <remarks>
+            <para>
+            Converts a string to an object. Uses the converter registry to try
+            to convert the string value into the specified target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.CanConvertTypeTo(System.Type,System.Type)">
+            <summary>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            </summary>
+            <param name="sourceType">The type to convert from.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns><c>true</c> if there is a conversion from the source type to the target type.</returns>
+            <remarks>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertTypeTo(System.Object,System.Type)">
+            <summary>
+            Converts an object to the target type.
+            </summary>
+            <param name="sourceInstance">The object to convert to the target type.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns>The converted object.</returns>
+            <remarks>
+            <para>
+            Converts an object to the target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">
+            <summary>
+            Instantiates an object given a class name.
+            </summary>
+            <param name="className">The fully qualified class name of the object to instantiate.</param>
+            <param name="superClass">The class to which the new object should belong.</param>
+            <param name="defaultValue">The object to return in case of non-fulfillment.</param>
+            <returns>
+            An instance of the <paramref name="className"/> or <paramref name="defaultValue"/>
+            if the object could not be instantiated.
+            </returns>
+            <remarks>
+            <para>
+            Checks that the <paramref name="className"/> is a subclass of
+            <paramref name="superClass"/>. If that test fails or the object could
+            not be instantiated, then <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.SubstituteVariables(System.String,System.Collections.IDictionary)">
+            <summary>
+            Performs variable substitution in string <paramref name="value"/> from the 
+            values of keys found in <paramref name="props"/>.
+            </summary>
+            <param name="value">The string on which variable substitution is performed.</param>
+            <param name="props">The dictionary to use to lookup variables.</param>
+            <returns>The result of the substitutions.</returns>
+            <remarks>
+            <para>
+            The variable substitution delimiters are <b>${</b> and <b>}</b>.
+            </para>
+            <para>
+            For example, if props contains <c>key=value</c>, then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of key is ${key}.");
+            </code>
+            </para>
+            <para>
+            will set the variable <c>s</c> to "Value of key is value.".
+            </para>
+            <para>
+            If no value could be found for the specified key, then substitution 
+            defaults to an empty string.
+            </para>
+            <para>
+            For example, if system properties contains no value for the key
+            "nonExistentKey", then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of nonExistentKey is [${nonExistentKey}]");
+            </code>
+            </para>
+            <para>
+            will set <s>s</s> to "Value of nonExistentKey is []".	 
+            </para>
+            <para>
+            An Exception is thrown if <paramref name="value"/> contains a start 
+            delimiter "${" which is not balanced by a stop delimiter "}". 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ParseEnum(System.Type,System.String,System.Boolean)">
+            <summary>
+            Converts the string representation of the name or numeric value of one or 
+            more enumerated constants to an equivalent enumerated object.
+            </summary>
+            <param name="enumType">The type to convert to.</param>
+            <param name="value">The enum string value.</param>
+            <param name="ignoreCase">If <c>true</c>, ignore case; otherwise, regard case.</param>
+            <returns>An object of type <paramref name="enumType" /> whose value is represented by <paramref name="value" />.</returns>
+        </member>
+        <member name="F:log4net.Util.OptionConverter.declaringType">
+            <summary>
+            The fully qualified type of the OptionConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser">
+            <summary>
+            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class
+            is delegated to the PatternParser class.
+            </summary>
+            <remarks>
+            <para>
+            The <c>PatternParser</c> processes a pattern string and
+            returns a chain of <see cref="T:log4net.Util.PatternConverter"/> objects.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.PatternParser.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="pattern">The pattern to parse.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternParser"/> class 
+            with the specified pattern string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.Parse">
+            <summary>
+            Parses the pattern into a chain of pattern converters.
+            </summary>
+            <returns>The head of a chain of pattern converters.</returns>
+            <remarks>
+            <para>
+            Parses the pattern into a chain of pattern converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.BuildCache">
+            <summary>
+            Build the unified cache of converters from the static and instance maps
+            </summary>
+            <returns>the list of all the converter names</returns>
+            <remarks>
+            <para>
+            Build the unified cache of converters from the static and instance maps
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ParseInternal(System.String,System.String[])">
+            <summary>
+            Internal method to parse the specified pattern to find specified matches
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <param name="matches">the converter names to match in the pattern</param>
+            <remarks>
+            <para>
+            The matches param must be sorted such that longer strings come before shorter ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessLiteral(System.String)">
+            <summary>
+            Process a parsed literal
+            </summary>
+            <param name="text">the literal text</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessConverter(System.String,System.String,log4net.Util.FormattingInfo)">
+            <summary>
+            Process a parsed converter pattern
+            </summary>
+            <param name="converterName">the name of the converter</param>
+            <param name="option">the optional option for the converter</param>
+            <param name="formattingInfo">the formatting info for the converter</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.AddConverter(log4net.Util.PatternConverter)">
+            <summary>
+            Resets the internal state of the parser and adds the specified pattern converter 
+            to the chain.
+            </summary>
+            <param name="pc">The pattern converter to add.</param>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_head">
+            <summary>
+            The first pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_tail">
+            <summary>
+             the last pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_pattern">
+            <summary>
+            The pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_patternConverters">
+            <summary>
+            Internal map of converter identifiers to converter types
+            </summary>
+            <remarks>
+            <para>
+            This map overrides the static s_globalRulesRegistry map.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternParser.declaringType">
+            <summary>
+            The fully qualified type of the PatternParser class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternParser.PatternConverters">
+            <summary>
+            Get the converter registry used by this parser
+            </summary>
+            <value>
+            The converter registry used by this parser
+            </value>
+            <remarks>
+            <para>
+            Get the converter registry used by this parser
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser.StringLengthComparer">
+            <summary>
+            Sort strings by length
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:System.Collections.IComparer"/> that orders strings by string length.
+            The longest strings are placed first
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternString">
+            <summary>
+            This class implements a patterned string.
+            </summary>
+            <remarks>
+            <para>
+            This string has embedded patterns that are resolved and expanded
+            when the string is formatted.
+            </para>
+            <para>
+            This class functions similarly to the <see cref="T:log4net.Layout.PatternLayout"/>
+            in that it accepts a pattern and renders it to a string. Unlike the 
+            <see cref="T:log4net.Layout.PatternLayout"/> however the <c>PatternString</c>
+            does not render the properties of a specific <see cref="T:log4net.Core.LoggingEvent"/> but
+            of the process in general.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+                        <para>
+                        Used to output the friendly name of the current AppDomain.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>appsetting</term>
+                    <description>
+                        <para>
+                        Used to output the value of a specific appSetting key in the application
+                        configuration file.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>date</term>
+                    <description>
+            			<para>
+            			Used to output the current date and time in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>env</term>
+                    <description>
+                        <para>
+            			Used to output the a specific environment variable. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%env{COMPUTERNAME}</b> would include the value
+            			of the <c>COMPUTERNAME</c> environment variable.
+                        </para>
+                        <para>
+                        The <c>env</c> pattern is not supported on the .NET Compact Framework.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>identity</term>
+                    <description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>newline</term>
+                    <description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern name offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+                    </description>
+                </item>
+                <item>
+                    <term>processid</term>
+                    <description>
+                        <para>
+            			Used to output the system process ID for the current process.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>property</term>
+                    <description>
+            			<para>
+            			Used to output a specific context property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are stored in logging contexts. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+                    </description>
+                </item>
+                <item>
+                    <term>random</term>
+                    <description>
+                        <para>
+                        Used to output a random string of characters. The string is made up of
+                        uppercase letters and numbers. By default the string is 4 characters long.
+                        The length of the string can be specified within braces directly following the
+            			pattern specifier, e.g. <b>%random{8}</b> would output an 8 character string.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>username</term>
+                    <description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>utcdate</term>
+                    <description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Util.PatternString"/>
+            instance using <see cref="M:AddConverter(ConverterInfo)"/> or
+            <see cref="M:AddConverter(string, Type)"/>.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.PatternLayout"/> for details on the 
+            <i>format modifiers</i> supported by the patterns.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternString.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternString only
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor(System.String)">
+            <summary>
+            Constructs a PatternString
+            </summary>
+            <param name="pattern">The pattern to use with this PatternString</param>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/> with the pattern specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.ActivateOptions">
+            <summary>
+            Initialize object options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternString.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternString.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternString.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.CreatePatternParser(System.String)">
+            <summary>
+            Create the <see cref="T:log4net.Util.PatternParser"/> used to parse the pattern
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/></returns>
+            <remarks>
+            <para>
+            Returns PatternParser used to parse the conversion string. Subclasses
+            may override this to return a subclass of PatternParser which recognize
+            custom conversion pattern name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format(System.IO.TextWriter)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the pattern to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format">
+            <summary>
+            Format the pattern as a string
+            </summary>
+            <returns>the pattern formatted as a string</returns>
+            <remarks>
+            <para>
+            Format the pattern to a string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a converter to this PatternString
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternString.ConversionPattern">
+            <summary>
+            Gets or sets the pattern formatting string
+            </summary>
+            <value>
+            The pattern formatting string
+            </value>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PropertiesDictionary">
+            <summary>
+            String keyed object map.
+            </summary>
+            <remarks>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.ReadOnlyPropertiesDictionary">
+            <summary>
+            String keyed object map that is read only.
+            </summary>
+            <remarks>
+            <para>
+            This collection is readonly and cannot be modified.
+            </para>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.ReadOnlyPropertiesDictionary.m_hashtable">
+            <summary>
+            The Hashtable used to store the properties data
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Copy Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Deserialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetKeys">
+            <summary>
+            Gets the key names.
+            </summary>
+            <returns>An array of all the keys.</returns>
+            <remarks>
+            <para>
+            Gets the key names.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Contains(System.String)">
+            <summary>
+            Test if the dictionary contains a specified key
+            </summary>
+            <param name="key">the key to look for</param>
+            <returns>true if the dictionary contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if the dictionary contains a specified key
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <param name="value"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.InnerHashtable">
+            <summary>
+            The hashtable used to store the properties
+            </summary>
+            <value>
+            The internal collection used to store the properties
+            </value>
+            <remarks>
+            <para>
+            The hashtable used to store the properties
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Count">
+            <summary>
+            The number of properties in this collection
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class 
+            with serialized data.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Because this class is sealed the serialization constructor is private.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Remove(System.String)">
+            <summary>
+            Remove the entry with the specified key from this dictionary
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+            <returns>an enumerator</returns>
+            <remarks>
+            <para>
+            Returns a <see cref="T:System.Collections.IDictionaryEnumerator"/> over the contest of this collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key">the key to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key">the key to lookup in the collection</param>
+            <returns><c>true</c> if the collection contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if this collection contains a specified key.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+            <remarks>
+            <para>
+            Remove all properties from the properties collection
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key">the key</param>
+            <param name="value">the value to store for the key</param>
+            <remarks>
+            <para>
+            Store a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+            <value>
+            <c>false</c>
+            </value>
+            <remarks>
+            <para>
+            This collection is modifiable. This property always
+            returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+            <value>
+            The value for the key specified.
+            </value>
+            <remarks>
+            <para>
+            Get or set a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="T:log4net.Util.PropertyEntry">
+            <summary>
+            A class to hold the key and data for a property set in the config file
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the key and data for a property set in the config file
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertyEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Key">
+            <summary>
+            Property Key
+            </summary>
+            <value>
+            Property Key
+            </value>
+            <remarks>
+            <para>
+            Property Key.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Value">
+            <summary>
+            Property Value
+            </summary>
+            <value>
+            Property Value
+            </value>
+            <remarks>
+            <para>
+            Property Value.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ProtectCloseTextWriter">
+            <summary>
+            A <see cref="T:System.IO.TextWriter"/> that ignores the <see cref="M:log4net.Util.ProtectCloseTextWriter.Close"/> message
+            </summary>
+            <remarks>
+            <para>
+            This writer is used in special cases where it is necessary 
+            to protect a writer from being closed by a client.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <remarks>
+            <para>
+            Create a new ProtectCloseTextWriter using a writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Attach(System.IO.TextWriter)">
+            <summary>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to attach to</param>
+            <remarks>
+            <para>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Close">
+            <summary>
+            Does not close the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Does not close the underlying output writer.
+            This method does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReaderWriterLock">
+            <summary>
+            Defines a lock that supports single writers and multiple readers
+            </summary>
+            <remarks>
+            <para>
+            <c>ReaderWriterLock</c> is used to synchronize access to a resource. 
+            At any given time, it allows either concurrent read access for 
+            multiple threads, or write access for a single thread. In a 
+            situation where a resource is changed infrequently, a 
+            <c>ReaderWriterLock</c> provides better throughput than a simple 
+            one-at-a-time lock, such as <see cref="T:System.Threading.Monitor"/>.
+            </para>
+            <para>
+            If a platform does not support a <c>System.Threading.ReaderWriterLock</c> 
+            implementation then all readers and writers are serialized. Therefore 
+            the caller must not rely on multiple simultaneous readers.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReaderWriterLock"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireReaderLock">
+            <summary>
+            Acquires a reader lock
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.AcquireReaderLock"/> blocks if a different thread has the writer 
+            lock, or if at least one thread is waiting for the writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock">
+            <summary>
+            Decrements the lock count
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock"/> decrements the lock count. When the count 
+            reaches zero, the lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireWriterLock">
+            <summary>
+            Acquires the writer lock
+            </summary>
+            <remarks>
+            <para>
+            This method blocks if another thread has a reader lock or writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseWriterLock">
+            <summary>
+            Decrements the lock count on the writer lock
+            </summary>
+            <remarks>
+            <para>
+            ReleaseWriterLock decrements the writer lock count. 
+            When the count reaches zero, the writer lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReusableStringWriter">
+            <summary>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.
+            This uses a single buffer for string operations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </summary>
+            <param name="formatProvider">the format provider to use</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">
+            <summary>
+            Override Dispose to prevent closing of writer
+            </summary>
+            <param name="disposing">flag</param>
+            <remarks>
+            <para>
+            Override Dispose to prevent closing of writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">
+            <summary>
+            Reset this string writer so that it can be reused.
+            </summary>
+            <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>
+            <param name="defaultSize">the default size to make the buffer</param>
+            <remarks>
+            <para>
+            Reset this string writer so that it can be reused.
+            The internal buffers are cleared and reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemInfo">
+            <summary>
+            Utility class for system specific information.
+            </summary>
+            <remarks>
+            <para>
+            Utility class of static methods for system specific information.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Alexey Solofnenko</author>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#ctor">
+            <summary>
+            Private constructor to prevent instances.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#cctor">
+            <summary>
+            Initialize default values for private static fields.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyLocationInfo(System.Reflection.Assembly)">
+            <summary>
+            Gets the assembly location path for the specified assembly.
+            </summary>
+            <param name="myAssembly">The assembly to get the location for.</param>
+            <returns>The location of the assembly.</returns>
+            <remarks>
+            <para>
+            This method does not guarantee to return the correct path
+            to the assembly. If only tries to give an indication as to
+            where the assembly was loaded from.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyQualifiedName(System.Type)">
+            <summary>
+            Gets the fully qualified name of the <see cref="T:System.Type"/>, including 
+            the name of the assembly from which the <see cref="T:System.Type"/> was 
+            loaded.
+            </summary>
+            <param name="type">The <see cref="T:System.Type"/> to get the fully qualified name for.</param>
+            <returns>The fully qualified name for the <see cref="T:System.Type"/>.</returns>
+            <remarks>
+            <para>
+            This is equivalent to the <c>Type.AssemblyQualifiedName</c> property,
+            but this method works on the .NET Compact Framework 1.0 as well as
+            the full .NET runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyShortName(System.Reflection.Assembly)">
+            <summary>
+            Gets the short name of the <see cref="T:System.Reflection.Assembly"/>.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the name for.</param>
+            <returns>The short name of the <see cref="T:System.Reflection.Assembly"/>.</returns>
+            <remarks>
+            <para>
+            The short name of the assembly is the <see cref="P:System.Reflection.Assembly.FullName"/> 
+            without the version, culture, or public key. i.e. it is just the 
+            assembly's file name without the extension.
+            </para>
+            <para>
+            Use this rather than <c>Assembly.GetName().Name</c> because that
+            is not available on the Compact Framework.
+            </para>
+            <para>
+            Because of a FileIOPermission security demand we cannot do
+            the obvious Assembly.GetName().Name. We are allowed to get
+            the <see cref="P:System.Reflection.Assembly.FullName"/> of the assembly so we 
+            start from there and strip out just the assembly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyFileName(System.Reflection.Assembly)">
+            <summary>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the file name for.</param>
+            <returns>The file name of the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Type,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeType">A sibling type to use to load the type.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified, it will be loaded from the assembly
+            containing the specified relative type. If the type is not found in the assembly 
+            then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>		
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the
+            assembly that is directly calling this method. If the type is not found 
+            in the assembly then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Reflection.Assembly,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeAssembly">An assembly to load the type from.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the specified
+            assembly. If the type is not found in the assembly then all the loaded assemblies 
+            will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.NewGuid">
+            <summary>
+            Generate a new guid
+            </summary>
+            <returns>A new Guid</returns>
+            <remarks>
+            <para>
+            Generate a new guid
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateArgumentOutOfRangeException(System.String,System.Object,System.String)">
+            <summary>
+            Create an <see cref="T:System.ArgumentOutOfRangeException"/>
+            </summary>
+            <param name="parameterName">The name of the parameter that caused the exception</param>
+            <param name="actualValue">The value of the argument that causes this exception</param>
+            <param name="message">The message that describes the error</param>
+            <returns>the ArgumentOutOfRangeException object</returns>
+            <remarks>
+            <para>
+            Create a new instance of the <see cref="T:System.ArgumentOutOfRangeException"/> class 
+            with a specified error message, the parameter name, and the value 
+            of the argument.
+            </para>
+            <para>
+            The Compact Framework does not support the 3 parameter constructor for the
+            <see cref="T:System.ArgumentOutOfRangeException"/> type. This method provides an
+            implementation that works for all platforms.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int32@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int32"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int64@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int64"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int16@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int16"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetAppSetting(System.String)">
+            <summary>
+            Lookup an application setting
+            </summary>
+            <param name="key">the application settings key to lookup</param>
+            <returns>the value for the key, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Configuration APIs are not supported under the Compact Framework
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified local file path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            <para>
+            The path specified must be a local file path, a URI is not supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateCaseInsensitiveHashtable">
+            <summary>
+            Creates a new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity. 
+            </summary>
+            <returns>A new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity</returns>
+            <remarks>
+            <para>
+            The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.EqualsIgnoringCase(System.String,System.String)">
+            <summary>
+            Tests two strings for equality, the ignoring case.
+            </summary>
+            <remarks>
+            If the platform permits, culture information is ignored completely (ordinal comparison).
+            The aim of this method is to provide a fast comparison that deals with <c>null</c> and ignores different casing.
+            It is not supposed to deal with various, culture-specific habits.
+            Use it to compare against pure ASCII constants, like keywords etc.
+            </remarks>
+            <param name="a">The one string.</param>
+            <param name="b">The other string.</param>
+            <returns><c>true</c> if the strings are equal, <c>false</c> otherwise.</returns>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.EmptyTypes">
+            <summary>
+            Gets an empty array of types.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Type.EmptyTypes</c> field is not available on
+            the .NET Compact Framework 1.0.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.declaringType">
+            <summary>
+            The fully qualified type of the SystemInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_hostName">
+            <summary>
+            Cache the host name for the current machine
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_appFriendlyName">
+            <summary>
+            Cache the application friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_nullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_notAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_processStartTimeUtc">
+            <summary>
+            Start time for the current process.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NewLine">
+            <summary>
+            Gets the system dependent line terminator.
+            </summary>
+            <value>
+            The system dependent line terminator.
+            </value>
+            <remarks>
+            <para>
+            Gets the system dependent line terminator.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationBaseDirectory">
+            <summary>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The base directory path for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ConfigurationFileLocation">
+            <summary>
+            Gets the path to the configuration file for the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the configuration file for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            The .NET Compact Framework 1.0 does not have a concept of a configuration
+            file. For this runtime, we use the entry assembly location as the root for
+            the configuration file name.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.EntryAssemblyLocation">
+            <summary>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the entry assembly.</value>
+            <remarks>
+            <para>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.CurrentThreadId">
+            <summary>
+            Gets the ID of the current thread.
+            </summary>
+            <value>The ID of the current thread.</value>
+            <remarks>
+            <para>
+            On the .NET framework, the <c>AppDomain.GetCurrentThreadId</c> method
+            is used to obtain the thread ID for the current thread. This is the 
+            operating system ID for the thread.
+            </para>
+            <para>
+            On the .NET Compact Framework 1.0 it is not possible to get the 
+            operating system thread ID for the current thread. The native method 
+            <c>GetCurrentThreadId</c> is implemented inline in a header file
+            and cannot be called.
+            </para>
+            <para>
+            On the .NET Framework 2.0 the <c>Thread.ManagedThreadId</c> is used as this
+            gives a stable id unrelated to the operating system thread ID which may 
+            change if the runtime is using fibers.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.HostName">
+            <summary>
+            Get the host name or machine name for the current machine
+            </summary>
+            <value>
+            The hostname or machine name
+            </value>
+            <remarks>
+            <para>
+            Get the host name or machine name for the current machine
+            </para>
+            <para>
+            The host name (<see cref="M:System.Net.Dns.GetHostName"/>) or
+            the machine name (<c>Environment.MachineName</c>) for
+            the current machine, or if neither of these are available
+            then <c>NOT AVAILABLE</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationFriendlyName">
+            <summary>
+            Get this application's friendly name
+            </summary>
+            <value>
+            The friendly name of this application as a string
+            </value>
+            <remarks>
+            <para>
+            If available the name of the application is retrieved from
+            the <c>AppDomain</c> using <c>AppDomain.CurrentDomain.FriendlyName</c>.
+            </para>
+            <para>
+            Otherwise the file name of the entry assembly is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTime">
+            <summary>
+            Get the start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTimeUtc">
+            <summary>
+            Get the UTC start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the UTC time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+            <remarks>
+            <para>
+            Use this value to indicate a <c>null</c> has been encountered while
+            outputting a string representation of an item.
+            </para>
+            <para>
+            The default value is <c>(null)</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NullText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NotAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+            <remarks>
+            <para>
+            Use this value when an unsupported feature is requested.
+            </para>
+            <para>
+            The default value is <c>NOT AVAILABLE</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NotAvailableText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemStringFormat">
+            <summary>
+            Utility class that represents a format string.
+            </summary>
+            <remarks>
+            <para>
+            Utility class that represents a format string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.#ctor(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Initialise the <see cref="T:log4net.Util.SystemStringFormat"/>
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.ToString">
+            <summary>
+            Format the string and arguments
+            </summary>
+            <returns>the formatted string</returns>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Replaces the format item in a specified <see cref="T:System.String"/> with the text equivalent 
+            of the value of a corresponding <see cref="T:System.Object"/> instance in a specified array.
+            A specified parameter supplies culture-specific formatting information.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+            <returns>
+            A copy of format in which the format items have been replaced by the <see cref="T:System.String"/> 
+            equivalent of the corresponding instances of <see cref="T:System.Object"/> in args.
+            </returns>
+            <remarks>
+            <para>
+            This method does not throw exceptions. If an exception thrown while formatting the result the
+            exception and arguments are returned in the result string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormatError(System.Exception,System.String,System.Object[])">
+            <summary>
+            Process an error during StringFormat
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderArray(System.Array,System.Text.StringBuilder)">
+            <summary>
+            Dump the contents of an array into a string builder
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderObject(System.Object,System.Text.StringBuilder)">
+            <summary>
+            Dump an object to a string
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemStringFormat.declaringType">
+            <summary>
+            The fully qualified type of the SystemStringFormat class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextProperties._dictionary">
+            <summary>
+            Each thread will automatically have its instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove a property
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetKeys">
+            <summary>
+            Get the keys stored in the properties.
+            </summary>
+            <para>
+            Gets the keys stored in the properties.
+            </para>
+            <returns>a set of the defined keys</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Clear">
+            <summary>
+            Clear all properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the <c>PropertiesDictionary</c> for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this tread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.ThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.ThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.ThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameStack">
+            <summary>
+            The ThreadContextStack internal stack
+            </summary>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.#ctor(System.Collections.Stack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.Transform">
+            <summary>
+            Utility class for transforming strings.
+            </summary>
+            <remarks>
+            <para>
+            Utility class for transforming strings.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.Transform.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.Transform"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.WriteEscapedXmlString(System.Xml.XmlWriter,System.String,System.String)">
+            <summary>
+            Write a string to an <see cref="T:System.Xml.XmlWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="textData">the string to write</param>
+            <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param>
+            <remarks>
+            <para>
+            The test is escaped either using XML escape entities
+            or using CDATA sections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.MaskXmlInvalidCharacters(System.String,System.String)">
+            <summary>
+            Replace invalid XML characters in text string
+            </summary>
+            <param name="textData">the XML text input string</param>
+            <param name="mask">the string to use in place of invalid characters</param>
+            <returns>A string that does not contain invalid XML characters.</returns>
+            <remarks>
+            <para>
+            Certain Unicode code points are not allowed in the XML InfoSet, for
+            details see: <a href="http://www.w3.org/TR/REC-xml/#charsets">http://www.w3.org/TR/REC-xml/#charsets</a>.
+            </para>
+            <para>
+            This method replaces any illegal characters in the input string
+            with the mask string specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.CountSubstrings(System.String,System.String)">
+            <summary>
+            Count the number of times that the substring occurs in the text
+            </summary>
+            <param name="text">the text to search</param>
+            <param name="substring">the substring to find</param>
+            <returns>the number of times the substring occurs in the text</returns>
+            <remarks>
+            <para>
+            The substring is assumed to be non repeating within itself.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.Transform.INVALIDCHARS">
+            <summary>
+            Characters illegal in XML 1.0
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext">
+            <summary>
+            Impersonate a Windows Account
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.SecurityContext"/> impersonates a Windows account.
+            </para>
+            <para>
+            How the impersonation is done depends on the value of <see cref="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)"/>.
+            This allows the context to either impersonate a set of user credentials specified 
+            using username, domain name and password or to revert to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.ActivateOptions">
+            <summary>
+            Initialize the SecurityContext based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The security context will try to Logon the specified user account and
+            capture a primary token for impersonation.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, 
+            <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> or <see cref="P:log4net.Util.WindowsSecurityContext.Password"/> properties were not specified.</exception>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.
+            </summary>
+            <param name="state">caller provided state</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> instance that will revoke the impersonation of this SecurityContext
+            </returns>
+            <remarks>
+            <para>
+            Depending on the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property either
+            impersonate a user using credentials supplied or revert 
+            to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.LogonUser(System.String,System.String,System.String)">
+            <summary>
+            Create a <see cref="T:System.Security.Principal.WindowsIdentity"/> given the userName, domainName and password.
+            </summary>
+            <param name="userName">the user name</param>
+            <param name="domainName">the domain name</param>
+            <param name="password">the password</param>
+            <returns>the <see cref="T:System.Security.Principal.WindowsIdentity"/> for the account specified</returns>
+            <remarks>
+            <para>
+            Uses the Windows API call LogonUser to get a principal token for the account. This
+            token is used to initialize the WindowsIdentity.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Credentials">
+            <summary>
+            Gets or sets the impersonation mode for this security context
+            </summary>
+            <value>
+            The impersonation mode for this security context
+            </value>
+            <remarks>
+            <para>
+            Impersonate either a user with user credentials or
+            revert this thread to the credentials of the process.
+            The value is one of the <see cref="T:log4net.Util.WindowsSecurityContext.ImpersonationMode"/>
+            enum.
+            </para>
+            <para>
+            The default value is <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            the user's credentials are established using the
+            <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.Password"/>
+            values.
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process"/>
+            no other properties need to be set. If the calling thread is 
+            impersonating then it will be reverted back to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.UserName">
+            <summary>
+            Gets or sets the Windows username for this security context
+            </summary>
+            <value>
+            The Windows username for this security context
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.DomainName">
+            <summary>
+            Gets or sets the Windows domain name for this security context
+            </summary>
+            <value>
+            The Windows domain name for this security context
+            </value>
+            <remarks>
+            <para>
+            The default value for <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> is the local machine name
+            taken from the <see cref="P:System.Environment.MachineName"/> property.
+            </para>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Password">
+            <summary>
+            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.
+            </summary>
+            <value>
+            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.
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.ImpersonationMode">
+            <summary>
+            The impersonation modes for the <see cref="T:log4net.Util.WindowsSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            See the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property for
+            details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User">
+            <summary>
+            Impersonate a user using the credentials supplied
+            </summary>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process">
+            <summary>
+            Revert this the thread to the credentials of the process
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext">
+            <summary>
+            Adds <see cref="T:System.IDisposable"/> to <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Helper class to expose the <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            through the <see cref="T:System.IDisposable"/> interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.#ctor(System.Security.Principal.WindowsImpersonationContext)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="impersonationContext">the impersonation context being wrapped</param>
+            <remarks>
+            <para>
+            Constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.Dispose">
+            <summary>
+            Revert the impersonation
+            </summary>
+            <remarks>
+            <para>
+            Revert the impersonation
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.GlobalContext">
+            <summary>
+            The log4net Global Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>GlobalContext</c> provides a location for global debugging 
+            information to be stored.
+            </para>
+            <para>
+            The global context has a properties map and these properties can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputing these properties.
+            </para>
+            <para>
+            By default the <c>log4net:HostName</c> property is set to the name of 
+            the current machine.
+            </para>
+            </remarks>
+            <example>
+            <code lang="C#">
+            GlobalContext.Properties["hostname"] = Environment.MachineName;
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.GlobalContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="F:log4net.GlobalContext.s_properties">
+            <summary>
+            The global context properties instance
+            </summary>
+        </member>
+        <member name="P:log4net.GlobalContext.Properties">
+            <summary>
+            The global properties map.
+            </summary>
+            <value>
+            The global properties map.
+            </value>
+            <remarks>
+            <para>
+            The global properties map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.AssemblyInfo">
+            <summary>
+            Provides information about the environment the assembly has
+            been built for.
+            </summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.Version">
+            <summary>Version of the assembly</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFrameworkVersion">
+            <summary>Version of the framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFramework">
+            <summary>Type of framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.ClientProfile">
+            <summary>Does it target a client profile?</summary>
+        </member>
+        <member name="P:log4net.AssemblyInfo.Info">
+            <summary>
+            Identifies the version and target for this assembly.
+            </summary>
+        </member>
+        <member name="T:log4net.LogicalThreadContext">
+            <summary>
+            The log4net Logical Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> provides a location for <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> specific debugging 
+            information to be stored.
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> or <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The Logical Thread Context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Logical Thread Context provides a diagnostic context for the current call context. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Logical Thread Context is managed on a per <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> basis.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            LogicalThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a LogicalThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.LogicalThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> 
+            or <see cref="T:log4net.GlobalContext"/> properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The logical thread stacks.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.LogManager">
+            <summary>
+            This class is used by client applications to request logger instances.
+            </summary>
+            <remarks>
+            <para>
+            This class has static methods that are used by a client to request
+            a logger instance. The <see cref="M:GetLogger(string)"/> method is 
+            used to retrieve a logger.
+            </para>
+            <para>
+            See the <see cref="T:log4net.ILog"/> interface for more details.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <seealso cref="T:log4net.ILog"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.LogManager.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.LogManager"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String)">
+            <overloads>Returns the named logger if it exists.</overloads>
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the default repository) then it
+            returns a reference to the logger, otherwise it returns <c>null</c>.
+            </para>
+            </remarks>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>The logger found, or <c>null</c> if no logger could be found.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers">
+            <overloads>Get the currently defined loggers.</overloads>
+            <summary>
+            Returns all the currently defined loggers in the default repository.
+            </summary>
+            <remarks>
+            <para>The root logger is <b>not</b> included in the returned array.</para>
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String)">
+            <overloads>Get or create a logger.</overloads>
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the logger doesn't exist in the specified 
+            repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the repository for the specified assembly) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger, or <c>null</c> if the logger doesn't exist in the specified
+            assembly's repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Get the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository">
+            <overloads>Shutdown a logger repository.</overloads>
+            <summary>
+            Shuts down the default repository.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            default repository.
+            </para>
+            <para>Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repository">The repository to shutdown.</param>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration">
+            <overloads>Reset the configuration of a repository</overloads>
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repository">The repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository">
+            <overloads>Get the logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository">
+            <overloads>Get a logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Type)">
+            <overloads>Create a domain</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Type)">
+            <overloads>Create a logger repository.</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetAllRepositories">
+            <summary>
+            Gets the list of currently defined repositories.
+            </summary>
+            <remarks>
+            <para>
+            Get an array of all the <see cref="T:log4net.Repository.ILoggerRepository"/> objects that have been created.
+            </para>
+            </remarks>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Flush(System.Int32)">
+            <summary>
+            Flushes logging events buffered in all configured appenders in the default repository.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLogger(log4net.Core.ILogger)">
+            <summary>
+            Looks up the wrapper object for the logger specified.
+            </summary>
+            <param name="logger">The logger to get the wrapper for.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLoggers(log4net.Core.ILogger[])">
+            <summary>
+            Looks up the wrapper objects for the loggers specified.
+            </summary>
+            <param name="loggers">The loggers to get the wrappers for.</param>
+            <returns>The wrapper objects for the loggers specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapperCreationHandler(log4net.Core.ILogger)">
+            <summary>
+            Create the <see cref="T:log4net.Core.ILoggerWrapper"/> objects used by
+            this manager.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="F:log4net.LogManager.s_wrapperMap">
+            <summary>
+            The wrapper map to use to hold the <see cref="T:log4net.Core.LogImpl"/> objects.
+            </summary>
+        </member>
+        <member name="T:log4net.MDC">
+            <summary>
+            Implementation of Mapped Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is
+            based on a map instead of a stack. It provides <i>mapped
+            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or
+            MDC in short, is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The MDC is managed on a per thread basis.
+            </para>
+            </remarks>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.MDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.MDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Get(System.String)">
+            <summary>
+            Gets the context value identified by the <paramref name="key"/> parameter.
+            </summary>
+            <param name="key">The key to lookup in the MDC.</param>
+            <returns>The string value held for the key, or a <c>null</c> reference if no corresponding value is found.</returns>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            If the <paramref name="key"/> parameter does not look up to a
+            previously defined context then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Set(System.String,System.String)">
+            <summary>
+            Add an entry to the MDC
+            </summary>
+            <param name="key">The key to store the value under.</param>
+            <param name="value">The value to store.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Puts a context value (the <paramref name="value"/> parameter) as identified
+            with the <paramref name="key"/> parameter into the current thread's
+            context map.
+            </para>
+            <para>
+            If a value is already defined for the <paramref name="key"/>
+            specified then the value will be replaced. If the <paramref name="value"/> 
+            is specified as <c>null</c> then the key value mapping will be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Remove(System.String)">
+            <summary>
+            Removes the key value mapping for the key specified.
+            </summary>
+            <param name="key">The key to remove.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove the specified entry from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Clear">
+            <summary>
+            Clear all entries in the MDC
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove all the entries from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.NDC">
+            <summary>
+            Implementation of Nested Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            A Nested Diagnostic Context, or NDC in short, is an instrument
+            to distinguish interleaved log output from different sources. Log
+            output is typically interleaved when a server handles multiple
+            clients near-simultaneously.
+            </para>
+            <para>
+            Interleaved log output can still be meaningful if each log entry
+            from different contexts had a distinctive stamp. This is where NDCs
+            come into play.
+            </para>
+            <para>
+            Note that NDCs are managed on a per thread basis. The NDC class
+            is made up of static methods that operate on the context of the
+            calling thread.
+            </para>
+            </remarks>
+            <example>How to push a message into the context
+            <code lang="C#">
+            using(NDC.Push("my context message"))
+            {
+            	... all log calls will have 'my context message' included ...
+            
+            } // at the end of the using block the message is automatically removed 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.NDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.NDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Clear">
+            <summary>
+            Clears all the contextual information held on the current thread.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Clears the stack of NDC data held on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.CloneStack">
+            <summary>
+            Creates a clone of the stack of context information.
+            </summary>
+            <returns>A clone of the context info for this thread.</returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The results of this method can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> 
+            method to allow child threads to inherit the context of their 
+            parent thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">
+            <summary>
+            Inherits the contextual information from another thread.
+            </summary>
+            <param name="stack">The context stack to inherit.</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This thread will use the context information from the stack
+            supplied. This can be used to initialize child threads with
+            the same contextual information as their parent threads. These
+            contexts will <b>NOT</b> be shared. Any further contexts that
+            are pushed onto the stack will not be visible to the other.
+            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to
+            this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Pop">
+            <summary>
+            Removes the top context from the stack.
+            </summary>
+            <returns>
+            The message in the context that was removed from the top 
+            of the stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Remove the top context from the stack, and return
+            it to the caller. If the stack is empty then an
+            empty string (not <c>null</c>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Push(System.String)">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.NDC.Push("NDC_Message"))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.PushFormat(System.String,System.Object[])">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="messageFormat">The new context message string format.</param>
+            <param name="args">Arguments to be passed into messageFormat.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            var someValue = "ExampleContext"
+            using(log4net.NDC.PushFormat("NDC_Message {0}", someValue))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.Remove">
+            <summary>
+            Removes the context information for this thread. It is
+            not required to call this method.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This method is not implemented.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">
+            <summary>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            </summary>
+            <param name="maxDepth">The maximum depth of the stack</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            This may truncate the head of the stack. This only affects the 
+            stack in the current thread. Also it does not prevent it from
+            growing, it only sets the maximum depth at the time of the
+            call. This can be used to return to a known context depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.NDC.Depth">
+            <summary>
+            Gets the current context depth.
+            </summary>
+            <value>The current context depth.</value>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The number of context values pushed onto the context stack.
+            </para>
+            <para>
+            Used to record the current depth of the context. This can then 
+            be restored using the <see cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/> method.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/>
+        </member>
+        <member name="T:log4net.ThreadContext">
+            <summary>
+            The log4net Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> provides a location for thread specific debugging 
+            information to be stored.
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            The thread context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Thread Context provides a diagnostic context for the current thread. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Thread Context is managed on a per thread basis.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            ThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a ThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(ThreadContext.Stacks["NDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a ThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.ThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.ThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.ThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.ThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The thread local stacks.
+            </para>
+            </remarks>
+        </member>
+    </members>
+</doc>
diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-client/log4net.dll b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-client/log4net.dll
new file mode 100644
index 0000000000000000000000000000000000000000..8deb7ddf70decdeb4213acac480d78e2143e08f2
GIT binary patch
literal 274944
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%0A@eH?5F@U
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

literal 0
HcmV?d00001

diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-client/log4net.xml b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-client/log4net.xml
new file mode 100644
index 000000000..d7d5be6e7
--- /dev/null
+++ b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-client/log4net.xml
@@ -0,0 +1,32259 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>log4net</name>
+    </assembly>
+    <members>
+        <member name="T:log4net.Appender.AdoNetAppender">
+            <summary>
+            Appender that logs to a database.
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
+            database. The appender can be configured to specify the connection 
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
+            property. For more information on database connection strings for
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
+            </para>
+            <para>
+            Records are written into the database either using a prepared
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
+            procedure.
+            </para>
+            <para>
+            The prepared statement text or the name of the stored procedure
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
+            </para>
+            <para>
+            The prepared statement or stored procedure can take a number
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
+            type may be subclassed if required to provide database specific
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
+            the parameter name, database type, size, and how the value should
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
+            </para>
+            </remarks>
+            <example>
+            An example of a SQL Server table that could be logged to:
+            <code lang="SQL">
+            CREATE TABLE [dbo].[Log] ( 
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,
+              [Date] [datetime] NOT NULL ,
+              [Thread] [varchar] (255) NOT NULL ,
+              [Level] [varchar] (20) NOT NULL ,
+              [Logger] [varchar] (255) NOT NULL ,
+              [Message] [varchar] (4000) NOT NULL 
+            ) ON [PRIMARY]
+            </code>
+            </example>
+            <example>
+            An example configuration to log to the above table:
+            <code lang="XML" escaped="true">
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
+              <parameter>
+                <parameterName value="@log_date"/>
+                <dbType value="DateTime"/>
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@thread"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@log_level"/>
+                <dbType value="String"/>
+                <size value="50"/>
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@logger"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@message"/>
+                <dbType value="String"/>
+                <size value="4000"/>
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>
+              </parameter>
+            </appender>
+            </code>
+            </example>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Lance Nehring</author>
+        </member>
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
+            buffers events in a fixed size buffer.
+            </summary>
+            <remarks>
+            <para>
+            This base class should be used by appenders that need to buffer a 
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            buffers events and then submits the entire contents of the buffer to 
+            the underlying database in one go.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:SendBuffer(LoggingEvent[])"/>
+            method to deliver the buffered events.
+            </para>
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
+            buffer of events. The size of the buffer is set using 
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
+            </para>
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
+            triggers, then the current buffer is sent immediately 
+            (see <see cref="M:SendBuffer(LoggingEvent[])"/>). Otherwise the event 
+            is stored in the buffer. For example, an evaluator can be used to 
+            deliver the events immediately when an ERROR event arrives.
+            </para>
+            <para>
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
+            By default the appender is NOT lossy. When the buffer is full all 
+            the buffered events are sent with <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
+            buffer will not be sent when it is full, and new events arriving 
+            in the appender will overwrite the oldest event in the buffer. 
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
+            triggers. This can be useful behavior when you need to know about 
+            ERROR events but not about events with a lower level, configure an 
+            evaluator that will trigger when an ERROR event arrives, the whole 
+            buffer will be sent which gives a history of events leading up to
+            the ERROR event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.AppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
+            </summary>
+            <remarks>
+            <para>
+            This class provides the code for common functionality, such 
+            as support for threshold filtering and support for general filters.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.IAppender">
+            <summary>
+            Implement this interface for your own strategies for printing log statements.
+            </summary>
+            <remarks>
+            <para>
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
+            class which provides a default implementation of this interface.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.IAppender.Close">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logging event in Appender specific way.
+            </summary>
+            <param name="loggingEvent">The event to log</param>
+            <remarks>
+            <para>
+            This method is called to log a message into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.IAppender.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>The name uniquely identifies the appender.</para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IBulkAppender">
+            <summary>
+            Interface for appenders that support bulk logging.
+            </summary>
+            <remarks>
+            <para>
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
+            should only implement this interface if they can bulk log efficiently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Log the array of logging events in Appender specific way.
+            </summary>
+            <param name="loggingEvents">The events to log</param>
+            <remarks>
+            <para>
+            This method is called to log an array of events into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IOptionHandler">
+            <summary>
+            Interface used to delay activate a configured object.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
+            must be called by the container after its all the configured properties have been set 
+            and before the component can be used.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
+            <summary>
+            Activate the options that were previously set with calls to properties.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then this method must be called
+            after its properties have been set before the component can be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IFlushable">
+            <summary>
+            Interface that can be implemented by Appenders that buffer logging data and expose a <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.IFlushable.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            Appenders that implement the <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method must do so in a thread-safe manner: it can be called concurrently with
+            the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            <para>
+            Typically this is done by locking on the Appender instance, e.g.:
+            <code>
+            <![CDATA[
+            public bool Flush(int millisecondsTimeout)
+            {
+                lock(this)
+                {
+                    // Flush buffered logging data
+                    ...
+                }
+            }
+            ]]>
+            </code>
+            </para>
+            <para>
+            The <paramref name="millisecondsTimeout"/> parameter is only relevant for appenders that process logging events asynchronously,
+            such as <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            </remarks>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>Empty default constructor</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
+            <summary>
+            Finalizes this appender by calling the implementation's 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
+            </summary>
+            <remarks>
+            <para>
+            If this appender has not been closed then the <c>Finalize</c> method
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">
+            <summary>
+            Closes the appender and release resources.
+            </summary>
+            <remarks>
+            <para>
+            Release any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            <para>
+            This method cannot be overridden by subclasses. This method 
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
+            method which must be overridden in the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent)"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>
+            will be passed to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent[])"/> method.
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent[])"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvents"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvents"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>
+            will be passed to the <see cref="M:Append(LoggingEvent[])"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if the logging event should we output by this appender
+            </summary>
+            <param name="loggingEvent">the event to test</param>
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
+            <remarks>
+            <para>
+            This method checks the logging event against the threshold level set
+            on this appender and also against the filters specified on this
+            appender.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
+            <summary>
+            Adds a filter to the end of the filter chain.
+            </summary>
+            <param name="filter">the filter to add to this appender</param>
+            <remarks>
+            <para>
+            The Filters are organized in a linked list.
+            </para>
+            <para>
+            Setting this property causes the new filter to be pushed onto the 
+            back of the filter chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
+            <summary>
+            Clears the filter list for this appender.
+            </summary>
+            <remarks>
+            <para>
+            Clears the filter list for this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
+            <summary>
+            Checks if the message level is below this appender's threshold.
+            </summary>
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
+            <remarks>
+            <para>
+            If there is no threshold set, then the return value is always <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
+            requirements of this appender.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
+            <summary>
+            Is called when the appender is closed. Derived classes should override 
+            this method if resources need to be released.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
+            to perform actual logging.
+            </summary>
+            <param name="loggingEvent">The event to append.</param>
+            <remarks>
+            <para>
+            A subclass must implement this method to perform
+            logging of the <paramref name="loggingEvent"/>.
+            </para>
+            <para>This method will be called by <see cref="M:DoAppend(LoggingEvent)"/>
+            if all the conditions listed for that method are met.
+            </para>
+            <para>
+            To restrict the logging of events in the appender
+            override the <see cref="M:PreAppendCheck()"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append a bulk array of logging events.
+            </summary>
+            <param name="loggingEvents">the array of logging events</param>
+            <remarks>
+            <para>
+            This base class implementation calls the <see cref="M:Append(LoggingEvent)"/>
+            method for each element in the bulk array.
+            </para>
+            <para>
+            A sub class that can better process a bulk array of events should
+            override this method in addition to <see cref="M:Append(LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
+            <summary>
+            Called before <see cref="M:Append(LoggingEvent)"/> as a precondition.
+            </summary>
+            <remarks>
+            <para>
+            This method is called by <see cref="M:DoAppend(LoggingEvent)"/>
+            before the call to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            This method can be overridden in a subclass to extend the checks 
+            made before the event is passed to the <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            A subclass should ensure that they delegate this call to
+            this base class if it is overridden.
+            </para>
+            </remarks>
+            <returns><c>true</c> if the call to <see cref="M:Append(LoggingEvent)"/> should proceed.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <returns>The event rendered as a string.</returns>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Where possible use the alternative version of this method
+            <see cref="M:RenderLoggingEvent(TextWriter,LoggingEvent)"/>.
+            That method streams the rendering onto an existing Writer
+            which can give better performance if the caller already has
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>
+            where possible. If, however, the caller needs to render the event
+            to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does
+            provide an efficient mechanism for doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            This implementation doesn't flush anything and always returns true
+            </remarks>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
+            <summary>
+            The layout of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
+            <summary>
+            The name of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
+            <summary>
+            The level threshold of this appender.
+            </summary>
+            <remarks>
+            <para>
+            There is no level threshold filtering by default.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
+            <summary>
+            It is assumed and enforced that errorHandler is never null.
+            </summary>
+            <remarks>
+            <para>
+            It is assumed and enforced that errorHandler is never null.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
+            <summary>
+            The first filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>null</c> initially.
+            </para>
+            <para>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
+            <summary>
+            The last filter in the filter chain.
+            </summary>
+            <remarks>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
+            <summary>
+            Flag indicating if this appender is closed.
+            </summary>
+            <remarks>
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
+            <summary>
+            The guard prevents an appender from repeatedly calling its own DoAppend method
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
+            <summary>
+            StringWriter used to render events
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.declaringType">
+            <summary>
+            The fully qualified type of the AppenderSkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
+            <summary>
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
+            </summary>
+            <value>
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
+            </value>
+            <remarks>
+            <para>
+            All log events with lower level than the threshold level are ignored 
+            by the appender.
+            </para>
+            <para>
+            In configuration files this option is specified by setting the
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
+            string, such as "DEBUG", "INFO" and so on.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </summary>
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
+            <summary>
+            The filter chain.
+            </summary>
+            <value>The head of the filter chain filter chain.</value>
+            <remarks>
+            <para>
+            Returns the head Filter. The Filters are organized in a linked list
+            and so all Filters on this Appender are available through the result.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
+            </summary>
+            <value>The layout of the appender.</value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>
+            The name uniquely identifies the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
+            <summary>
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <remarks>
+            <para>
+            In the rather exceptional case, where the appender 
+            implementation admits a layout but can also work without it, 
+            then the appender should return <c>true</c>.
+            </para>
+            <para>
+            This default implementation always returns <c>false</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
+            <summary>
+            The default buffer size.
+            </summary>
+            <remarks>
+            The default size of the cyclic buffer used to store events.
+            This is set to 512 by default.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <param name="eventMustBeFixed">the events passed through this appender must be
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
+            <remarks>
+            <para>
+            Protected constructor to allow subclassing.
+            </para>
+            <para>
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass
+            expects the events delivered to be fixed even if the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <remarks>
+            <para>
+            Flushes any events that have been buffered.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will NOT be flushed to the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
+            <remarks>
+            <para>
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
+            In this case the contents of the buffer will be tested against the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
+            events will be discarded.
+            </para>
+            <para>
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
+            be emptied by calling this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
+            <summary>
+            Close this appender instance.
+            </summary>
+            <remarks>
+            <para>
+            Close this appender instance. If this appender is marked
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
+            the buffer must be sent when the appender is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
+            </para>
+            <para>
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
+            method) if one of the following conditions is met:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>The cyclic buffer is full and this appender is
+            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
+            	</item>
+            	<item>
+            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
+            		it is triggered for the <paramref name="loggingEvent"/>
+            		specified.</description>
+            	</item>
+            </list>
+            <para>
+            Before the event is stored in the buffer it is fixed
+            (see <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/>) to ensure that
+            any data referenced by the event will be valid when the buffer
+            is processed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
+            <summary>
+            Sends the contents of the buffer.
+            </summary>
+            <param name="firstLoggingEvent">The first logging event.</param>
+            <param name="buffer">The buffer containing the events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override this method to process the buffered events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
+            <summary>
+            The size of the cyclic buffer used to hold the logging events.
+            </summary>
+            <remarks>
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
+            <summary>
+            The cyclic buffer used to store the logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
+            <summary>
+            The triggering event evaluator that causes the buffer to be sent immediately.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event causes the entire
+            buffer to be sent immediately. This field can be <c>null</c>, which 
+            indicates that event triggering is not to be done. The evaluator
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
+            <summary>
+            Indicates if the appender should overwrite events in the cyclic buffer 
+            when it becomes full, or if the buffer should be flushed when the 
+            buffer is full.
+            </summary>
+            <remarks>
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
+            be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
+            <summary>
+            The triggering event evaluator filters discarded events.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event that is discarded should
+            really be discarded or if it should be sent to the appenders. 
+            This field can be <c>null</c>, which indicates that all discarded events will
+            be discarded. 
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
+            <summary>
+            The events delivered to the subclass must be fixed.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
+            <summary>
+            Gets or sets a value that indicates whether the appender is lossy.
+            </summary>
+            <value>
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            This appender uses a buffer to store logging events before 
+            delivering them. A triggering event causes the whole buffer
+            to be send to the remote sink. If the buffer overruns before
+            a triggering event then logging events could be lost. Set
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
+            from being lost.
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
+            <summary>
+            Gets or sets the size of the cyclic buffer used to hold the 
+            logging events.
+            </summary>
+            <value>
+            The size of the cyclic buffer used to hold the logging events.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
+            representing the maximum number of logging events to collect in 
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
+            oldest events are deleted as new events are added to the
+            buffer. By default the size of the cyclic buffer is 512 events.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
+            or equal to 1 then no buffering will occur. The logging event
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
+            be buffered.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
+            buffer to be sent immediately.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
+            sent immediately.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is appended to this 
+            appender. If the evaluator triggers then the current buffer will 
+            immediately be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
+            <summary>
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </summary>
+            <value>
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is discarded from this 
+            appender. If the evaluator triggers then the current buffer will immediately 
+            be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating if only part of the logging event data
+            should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the
+            event data to be fixed and serialized. This will improve performance.
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
+            <summary>
+            Gets or sets a the fields that will be fixed in the event
+            </summary>
+            <value>
+            The event fields that will be fixed before the event is buffered
+            </value>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
+            <summary> 
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
+            </summary>
+            <remarks>
+            Public default constructor to initialize a new instance of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
+            <summary>
+            Override the parent method to close the database
+            </summary>
+            <remarks>
+            <para>
+            Closes the database command and database connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Inserts the events into the database.
+            </summary>
+            <param name="events">The events to insert into the database.</param>
+            <remarks>
+            <para>
+            Insert all the events specified in the <paramref name="events"/>
+            array into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
+            <summary>
+            Adds a parameter to the command.
+            </summary>
+            <param name="parameter">The parameter to add to the command.</param>
+            <remarks>
+            <para>
+            Adds a parameter to the ordered list of command parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
+            <summary>
+            Writes the events to the database using the transaction specified.
+            </summary>
+            <param name="dbTran">The transaction that the events will be executed under.</param>
+            <param name="events">The array of events to insert into the database.</param>
+            <remarks>
+            <para>
+            The transaction argument can be <c>null</c> if the appender has been
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
+            property for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
+            <summary>
+            Formats the log message into database statement text.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            This method can be overridden by subclasses to provide 
+            more control over the format of the database statement.
+            </remarks>
+            <returns>
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.CreateConnection(System.Type,System.String)">
+            <summary>
+            Creates an <see cref="T:System.Data.IDbConnection"/> instance used to connect to the database.
+            </summary>
+            <remarks>
+            This method is called whenever a new IDbConnection is needed (i.e. when a reconnect is necessary).
+            </remarks>
+            <param name="connectionType">The <see cref="T:System.Type"/> of the <see cref="T:System.Data.IDbConnection"/> object.</param>
+            <param name="connectionString">The connectionString output from the ResolveConnectionString method.</param>
+            <returns>An <see cref="T:System.Data.IDbConnection"/> instance with a valid connection string.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionString(System.String@)">
+            <summary>
+            Resolves the connection string from the ConnectionString, ConnectionStringName, or AppSettingsKey
+            property.
+            </summary>
+            <remarks>
+            ConnectiongStringName is only supported on .NET 2.0 and higher.
+            </remarks>
+            <param name="connectionStringContext">Additional information describing the connection string.</param>
+            <returns>A connection string used to connect to the database.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
+            <summary>
+            Retrieves the class type of the ADO.NET provider.
+            </summary>
+            <remarks>
+            <para>
+            Gets the Type of the ADO.NET provider to use to connect to the
+            database. This method resolves the type specified in the 
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
+            </para>
+            <para>
+            Subclasses can override this method to return a different type
+            if necessary.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
+            <summary>
+            Connects to the database.
+            </summary>		
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.DiposeConnection">
+            <summary>
+            Cleanup the existing connection.
+            </summary>
+            <remarks>
+            Calls the IDbConnection's <see cref="M:System.Data.IDbConnection.Close"/> method.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
+            <summary>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </summary>
+            <remarks>
+            <para>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
+            <summary>
+            The <see cref="T:System.Data.IDbConnection"/> that will be used
+            to insert logging events into a database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
+            <summary>
+            Database connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_appSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
+            <summary>
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
+            <summary>
+            The text of the command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
+            <summary>
+            The command type.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
+            <summary>
+            Indicates whether to reconnect when a connection is lost.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.declaringType">
+            <summary>
+            The fully qualified type of the AdoNetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
+            <summary>
+            Gets or sets the database connection string that is used to connect to 
+            the database.
+            </summary>
+            <value>
+            The database connection string used to connect to the database.
+            </value>
+            <remarks>
+            <para>
+            The connections string is specific to the connection type.
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
+            </para>
+            </remarks>
+            <example>Connection string for MS Access via ODBC:
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
+            </example>
+            <example>Another connection string for MS Access via ODBC:
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
+            </example>
+            <example>Connection string for MS Access via OLE DB:
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.AppSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+            <remarks>
+            This property requires at least .NET 2.0.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
+            <summary>
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
+            that should be created.
+            </summary>
+            <value>
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
+            </value>
+            <remarks>
+            <para>
+            The type name of the ADO.NET provider to use.
+            </para>
+            <para>
+            The default is to use the OLE DB provider.
+            </para>
+            </remarks>
+            <example>Use the OLE DB Provider. This is the default value.
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the MS SQL Server Provider. 
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the ODBC Provider. 
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>ODBC .NET Data Provider</b>.
+            </example>
+            <example>Use the Oracle Provider. 
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>.NET Managed Provider for Oracle</b>.
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
+            <summary>
+            Gets or sets the command text that is used to insert logging events
+            into the database.
+            </summary>
+            <value>
+            The command text used to insert logging events into the database.
+            </value>
+            <remarks>
+            <para>
+            Either the text of the prepared statement or the
+            name of the stored procedure to execute to write into
+            the database.
+            </para>
+            <para>
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
+            this text is a prepared statement or a stored procedure.
+            </para>
+            <para>
+            If this property is not set, the command text is retrieved by invoking
+            <see cref="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
+            <summary>
+            Gets or sets the command type to execute.
+            </summary>
+            <value>
+            The command type to execute.
+            </value>
+            <remarks>
+            <para>
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
+            to execute.
+            </para>
+            <para>
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
+            <summary>
+            Should transactions be used to insert logging events in the database.
+            </summary>
+            <value>
+            <c>true</c> if transactions should be used to insert logging events in
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a value that indicates whether transactions should be used
+            to insert logging events in the database.
+            </para>
+            <para>
+            When set a single transaction will be used to insert the buffered events
+            into the database. Otherwise each event will be inserted without using
+            an explicit transaction.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
+            <summary>
+            Should this appender try to reconnect to the database on error.
+            </summary>
+            <value>
+            <c>true</c> if the appender should try to reconnect to the database after an
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
+            i.e. not to try to reconnect.
+            </value>
+            <remarks>
+            <para>
+            The default behaviour is for the appender not to try to reconnect to the
+            database if an error occurs. Subsequent logging events are discarded.
+            </para>
+            <para>
+            To force the appender to attempt to reconnect to the database set this
+            property to <c>true</c>.
+            </para>
+            <note>
+            When the appender attempts to connect to the database there may be a
+            delay of up to the connection timeout specified in the connection string.
+            This delay will block the calling application's thread. 
+            Until the connection can be reestablished this potential delay may occur multiple times.
+            </note>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Data.IDbConnection"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">
+            <summary>
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            This class provides the basic database parameter properties
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
+            </para>
+            <para>This type can be subclassed to provide database specific
+            functionality. The two methods that are called externally are
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.
+            </summary>
+            <remarks>
+            Default constructor for the AdoNetAppenderParameter class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">
+            <summary>
+            Prepare the specified database command object.
+            </summary>
+            <param name="command">The command to prepare.</param>
+            <remarks>
+            <para>
+            Prepares the database command object by adding
+            this parameter to its collection of parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the logging event and set the parameter value in the command.
+            </summary>
+            <param name="command">The command containing the parameter.</param>
+            <param name="loggingEvent">The event to be rendered.</param>
+            <remarks>
+            <para>
+            Renders the logging event using this parameters layout
+            object. Sets the value of the parameter on the command object.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">
+            <summary>
+            The name of this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">
+            <summary>
+            The database type for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">
+            <summary>
+            Flag to infer type rather than use the DbType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">
+            <summary>
+            The precision for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">
+            <summary>
+            The scale for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">
+            <summary>
+            The size for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">
+            <summary>
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the
+            logging event into an object for this parameter.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">
+            <summary>
+            Gets or sets the name of this parameter.
+            </summary>
+            <value>
+            The name of this parameter.
+            </value>
+            <remarks>
+            <para>
+            The name of this parameter. The parameter name
+            must match up to a named parameter to the SQL stored procedure
+            or prepared statement.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">
+            <summary>
+            Gets or sets the database type for this parameter.
+            </summary>
+            <value>
+            The database type for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The database type for this parameter. This property should
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the type from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">
+            <summary>
+            Gets or sets the precision for this parameter.
+            </summary>
+            <value>
+            The precision for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum number of digits used to represent the Value.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the precision from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">
+            <summary>
+            Gets or sets the scale for this parameter.
+            </summary>
+            <value>
+            The scale for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The number of decimal places to which Value is resolved.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the scale from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">
+            <summary>
+            Gets or sets the size for this parameter.
+            </summary>
+            <value>
+            The size for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum size, in bytes, of the data within the column.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the size from the value.
+            </para>
+            <para>
+            For BLOB data types like VARCHAR(max) it may be impossible to infer the value automatically, use -1 as the size in this case.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to 
+            render the logging event into an object for this 
+            parameter.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the
+            logging event into an object for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this
+            parameter.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>
+            for use in the property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">
+            <summary>
+            Appends logging events to the terminal using ANSI color escape sequences.
+            </summary>
+            <remarks>
+            <para>
+            AnsiColorTerminalAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific level of message to be set.
+            </para>
+            <note>
+            This appender expects the terminal to understand the VT100 control set 
+            in order to interpret the color codes. If the terminal or console does not
+            understand the control codes the behavior is not defined.
+            </note>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            <para>
+            When configuring the ANSI colored terminal appender, a mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red"/>
+                <attributes value="Bright,Underscore"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            </list>
+            These color values cannot be combined together to make new colors.
+            </para>
+            <para>
+            The attributes can be any combination of the following:
+            <list type="bullet">
+            <item><term>Bright</term><description>foreground is brighter</description></item>
+            <item><term>Dim</term><description>foreground is dimmer</description></item>
+            <item><term>Underscore</term><description>message is underlined</description></item>
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>
+            <item><term>Hidden</term><description>output is hidden</description></item>
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>
+            </list>
+            While any of these attributes may be combined together not all combinations
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes
+            no sense.
+            </para>
+            </remarks>
+            <author>Patrick Wagstrom</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">
+            <summary>
+            Ansi code to reset terminal
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colours
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">
+            <summary>
+            The enum of possible display attributes
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the ANSI color attributes.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">
+            <summary>
+            text is bright
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">
+            <summary>
+            text is dim
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">
+            <summary>
+            text is underlined
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">
+            <summary>
+            text is blinking
+            </summary>
+            <remarks>
+            Not all terminals support this attribute
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">
+            <summary>
+            text and background colors are reversed
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">
+            <summary>
+            text is hidden
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">
+            <summary>
+            text is displayed with a strikethrough
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Light">
+            <summary>
+            text color is light
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">
+            <summary>
+            The enum of possible foreground or background color values for 
+            use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The output can be in one for the following ANSI colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">
+            <summary>
+            color is black
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">
+            <summary>
+            color is magenta
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMappingEntry">
+            <summary>
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract base class for types that are stored in the
+            <see cref="T:log4net.Util.LevelMapping"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">
+            <summary>
+            Default protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Default protected constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
+            <summary>
+            Initialize any options defined on this entry
+            </summary>
+            <remarks>
+            <para>
+            Should be overridden by any classes that need to initialise based on their options
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LevelMappingEntry.Level">
+            <summary>
+            The level that is the key for this mapping 
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping 
+            </value>
+            <remarks>
+            <para>
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
+            mapping subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together
+            and append the attributes.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">
+            <summary>
+            The color attributes for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The color attributes for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            An <c>AppenderCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">
+            <summary>
+            An empty readonly static AppenderCollection
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <c>AppenderCollection</c>.
+            </summary>
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">
+            <summary>
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clear">
+            <summary>
+            Removes all elements from the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>
+            in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">
+            <summary>
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">
+            <summary>
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">
+            <summary>
+            Return the collection elements as an array
+            </summary>
+            <returns>the array</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            	<para><paramref name="index"/> is less than zero</para>
+            	<para>-or-</para>
+            	<para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Appender.BufferingForwardingAppender">
+            <summary>
+            Buffers events and then forwards them to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The events are buffered in this appender until conditions are
+            met to allow the appender to deliver the events to the attached 
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the
+            conditions that cause the buffer to be sent.
+            </para>
+            <para>The forwarding appender can be used to specify different 
+            thresholds and filters for the same appender at different locations 
+            within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Core.IAppenderAttachable">
+            <summary>
+            Interface for attaching appenders to objects.
+            </summary>
+            <remarks>
+            <para>
+            Interface for attaching, removing and retrieving appenders.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="appender">The appender to add.</param>
+            <remarks>
+            <para>
+            Add the specified appender. The implementation may
+            choose to allow or deny duplicate appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Returns an attached appender with the <paramref name="name"/> specified.
+            If no appender with the specified name is found <c>null</c> will be
+            returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <value>
+            A collection of attached appenders.
+            </value>
+            <remarks>
+            <para>
+            Gets a collection of attached appenders.
+            If there are no attached appenders the
+            implementation should return an empty 
+            collection rather than <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            Forwards the events to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this buffering appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes directly to the application's attached console
+            not to the <c>System.Console.Out</c> or <c>System.Console.Error</c> <c>TextWriter</c>.
+            The <c>System.Console.Out</c> and <c>System.Console.Error</c> streams can be
+            programmatically redirected (for example NUnit does this to capture program output).
+            This appender will ignore these redirections because it needs to use Win32
+            API calls to colorize the output. To respect these redirections the <see cref="T:log4net.Appender.ConsoleAppender"/>
+            must be used.
+            </para>
+            <para>
+            When configuring the colored console appender, mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red, HighIntensity"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            combination of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            <item><term>HighIntensity</term><description></description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.AddMapping(log4net.Appender.ColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_consoleOutputWriter">
+            <summary>
+            The console output stream writer to write to
+            </summary>
+            <remarks>
+            <para>
+            This writer is not thread safe.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.Colors">
+            <summary>
+            The enum of possible color values for use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.ColoredConsoleAppender"/>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Purple">
+            <summary>
+            color is purple
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.HighIntensity">
+            <summary>
+            color is intensified
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> together.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> suitable for 
+            setting the console color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.DebugAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the
+            debug system.
+            </para>
+            <para>
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(string,string)"/>
+            method. The event's logger name is passed as the value for the category name to the Write method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>
+            is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_category">
+            <summary>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.Category">
+            <summary>
+            Formats the category parameter sent to the Debug method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender">
+            <summary>
+            Writes events to the system event log.
+            </summary>
+            <remarks>
+            <para>
+            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.
+            See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog
+            </para>
+            <para>
+            The <c>EventID</c> of the event log entry can be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            The <c>Category</c> of the event log entry can be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            <para>
+            When configuring the EventLogAppender a mapping can be
+            specified to map a logging level to an event log entry type. For example:
+            </para>
+            <code lang="XML">
+            &lt;mapping&gt;
+            	&lt;level value="ERROR" /&gt;
+            	&lt;eventLogEntryType value="Error" /&gt;
+            &lt;/mapping&gt;
+            &lt;mapping&gt;
+            	&lt;level value="DEBUG" /&gt;
+            	&lt;eventLogEntryType value="Information" /&gt;
+            &lt;/mapping&gt;
+            </code>
+            <para>
+            The Level is the standard log4net logging level and eventLogEntryType can be any value
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:
+            <list type="bullet">
+            <item><term>Error</term><description>an error event</description></item>
+            <item><term>Warning</term><description>a warning event</description></item>
+            <item><term>Information</term><description>an informational event</description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Thomas Voss</author>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.
+            </summary>
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">
+            <summary>
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.
+            Each mapping defines the event log entry type for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">
+            <summary>
+            Create an event log source
+            </summary>
+            <remarks>
+            Uses different API calls under NET_2_0
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Writes the event to the system event log using the 
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>
+            
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            set then this integer will be used as the event log event id.</para>
+            
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">
+            <summary>
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/>
+            </summary>
+            <param name="level">the Level to convert to an EventLogEntryType</param>
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/></returns>
+            <remarks>
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
+            values to use in logging levels than there are in the 
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is
+            a loss of information during the conversion.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">
+            <summary>
+            The log name is the section in the event logs where the messages
+            are stored.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
+            <summary>
+            Name of the application to use when logging.  This appears in the
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
+            <summary>
+            The name of the machine which holds the event log. This is
+            currently only allowed to be '.' i.e. the current machine.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to EventLogEntryType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_eventId">
+            <summary>
+            The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_category">
+            <summary>
+            The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.declaringType">
+            <summary>
+            The fully qualified type of the EventLogAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_DEFAULT">
+            <summary>
+            The maximum size supported by default.
+            </summary>
+            <remarks>
+            http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx
+            The 32766 documented max size is two bytes shy of 32K (I'm assuming 32766 
+            may leave space for a two byte null terminator of #0#0). The 32766 max 
+            length is what the .NET 4.0 source code checks for, but this is WRONG! 
+            Strings with a length > 31839 on Windows Vista or higher can CORRUPT 
+            the event log! See: System.Diagnostics.EventLogInternal.InternalWriteEvent() 
+            for the use of the 32766 max size.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_VISTA_OR_NEWER">
+            <summary>
+            The maximum size supported by a windows operating system that is vista
+            or newer.
+            </summary>
+            <remarks>
+            See ReportEvent API:
+            	http://msdn.microsoft.com/en-us/library/aa363679(VS.85).aspx
+            ReportEvent's lpStrings parameter:
+            "A pointer to a buffer containing an array of 
+            null-terminated strings that are merged into the message before Event Viewer 
+            displays the string to the user. This parameter must be a valid pointer 
+            (or NULL), even if wNumStrings is zero. Each string is limited to 31,839 characters."
+            
+            Going beyond the size of 31839 will (at some point) corrupt the event log on Windows
+            Vista or higher! It may succeed for a while...but you will eventually run into the
+            error: "System.ComponentModel.Win32Exception : A device attached to the system is
+            not functioning", and the event log will then be corrupt (I was able to corrupt 
+            an event log using a length of 31877 on Windows 7).
+            
+            The max size for Windows Vista or higher is documented here:
+            	http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx.
+            Going over this size may succeed a few times but the buffer will overrun and 
+            eventually corrupt the log (based on testing).
+            
+            The maxEventMsgSize size is based on the max buffer size of the lpStrings parameter of the ReportEvent API.
+            The documented max size for EventLog.WriteEntry for Windows Vista and higher is 31839, but I'm leaving room for a
+            terminator of #0#0, as we cannot see the source of ReportEvent (though we could use an API monitor to examine the
+            buffer, given enough time).
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE">
+            <summary>
+            The maximum size that the operating system supports for
+            a event log message.
+            </summary>
+            <remarks>
+            Used to determine the maximum string length that can be written
+            to the operating system event log and eventually truncate a string
+            that exceeds the limits.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetMaxEventLogMessageSize">
+            <summary>
+            This method determines the maximum event log message size allowed for
+            the current environment.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.LogName">
+            <summary>
+            The name of the log where messages will be stored.
+            </summary>
+            <value>
+            The string name of the log where messages will be stored.
+            </value>
+            <remarks>
+            <para>This is the name of the log as it appears in the Event Viewer
+            tree. The default value is to log into the <c>Application</c>
+            log, this is where most applications write their events. However
+            if you need a separate log for your application (or applications)
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
+            <para>This should not be used to distinguish your event log messages
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
+            property should be used to distinguish events. This property should be 
+            used to group together events into a single log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
+            <summary>
+            Property used to set the Application name.  This appears in the
+            event logs when logging.
+            </summary>
+            <value>
+            The string used to distinguish events from different sources.
+            </value>
+            <remarks>
+            Sets the event log source property.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">
+            <summary>
+            This property is used to return the name of the computer to use
+            when accessing the event logs.  Currently, this is the current
+            computer, denoted by a dot "."
+            </summary>
+            <value>
+            The string name of the machine holding the event log that 
+            will be logged into.
+            </value>
+            <remarks>
+            This property cannot be changed. It is currently set to '.'
+            i.e. the local machine. This may be changed in future.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </value>
+            <remarks>
+            <para>
+            The system security context used to write to the EventLog.
+            </para>
+            <para>
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.EventId">
+            <summary>
+            Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>EventID</c> of the event log entry will normally be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Category">
+            <summary>
+            Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Category</c> of the event log entry will normally be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and its event log entry type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">
+            <summary>
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender">
+            <summary>
+            Appends logging events to a file.
+            </summary>
+            <remarks>
+            <para>
+            Logging events are sent to the file specified by
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.
+            </para>
+            <para>
+            The file can be opened in either append or overwrite mode 
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.
+            If the file path is relative it is taken as relative from 
+            the application base directory. The file encoding can be
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.
+            </para>
+            <para>
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            values will be written each time the file is opened and closed
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>
+            then the file may contain multiple copies of the header and footer.
+            </para>
+            <para>
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> 
+            is to obtain an exclusive write lock on the file until this appender is closed.
+            The alternative models only hold a
+            write lock while the appender is writing a logging event (<see cref="T:log4net.Appender.FileAppender.MinimalLock"/>)
+            or synchronize by using a named system wide Mutex (<see cref="T:log4net.Appender.FileAppender.InterProcessLock"/>).
+            </para>
+            <para>
+            All locking strategies have issues and you should seriously consider using a different strategy that
+            avoids having multiple processes logging to the same file.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Rodrigo B. de Oliveira</author>
+            <author>Douglas de la Torre</author>
+            <author>Niall Daley</author>
+        </member>
+        <member name="T:log4net.Appender.TextWriterAppender">
+            <summary>
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This appender may be used stand alone if initialized with an appropriate
+            writer, however it is typically used as a base class for an appender that
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized 
+            with the specified <see cref="T:System.IO.Stream"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender</param>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
+            <remarks>
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
+            <summary>
+            This method determines if there is a sense in attempting to append.
+            </summary>
+            <remarks>
+            <para>
+            This method checks if an output target has been set and if a
+            layout has been set. 
+            </para>
+            </remarks>
+            <returns><c>false</c> if any of the preconditions fail.</returns>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method writes all the bulk logged events to the output writer
+            before flushing the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+            <remarks>
+            Closed appenders cannot be reused.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
+            <summary>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">
+            <summary>
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> 
+            and other variables.
+            </summary>
+            <remarks>
+            <para>
+            Subclasses can override this method for an alternate closing behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
+            <summary>
+            Called to allow a subclass to lazily initialize the writer
+            </summary>
+            <remarks>
+            <para>
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
+            attempt to initialize the writer multiple times.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
+            <summary>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> 
+            or output stream will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logging events are not actually persisted if and when the application 
+            crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.declaringType">
+            <summary>
+            The fully qualified type of the TextWriterAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
+            <summary>
+            Gets or set whether the appender will flush at the end 
+            of each append operation.
+            </summary>
+            <value>
+            <para>
+            The default behavior is to flush at the end of each 
+            append operation.
+            </para>
+            <para>
+            If this option is set to <c>false</c>, then the underlying 
+            stream can defer persisting the logging event to a later 
+            time.
+            </para>
+            </value>
+            <remarks>
+            Avoiding the flush operation at the end of each append results in
+            a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">
+            <summary>
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
+            </summary>
+            <remarks>
+            <para>
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
+            </para>
+            <para>
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender 
+            instance is closed.
+            </para>
+            <para>
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
+            <summary>
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying 
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </value>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
+            </value>
+            <remarks>
+            <para>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
+            <summary>
+            Construct a new appender using the layout, file and append mode.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <param name="append">flag to indicate if the file should be appended to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
+            <summary>
+            Construct a new appender using the layout and file specified.
+            The file will be appended to.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
+            <summary>
+            Activate the options on the file appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This will cause the file to be opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Reset">
+            <summary>
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.
+            </summary>
+            <remarks>
+            <para>
+            Resets the filename and the file stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">
+            <summary>
+            Called to initialize the file writer
+            </summary>
+            <remarks>
+            <para>
+            Will be called for each logged message until the file is
+            successfully opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Acquires the output file locks once before writing all the events to
+            the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseFile">
+            <summary>
+            Closes the previously opened file.
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then
+            closes the file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            If there was already an opened file, then the previous file
+            is closed first.
+            </para>
+            <para>
+            This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">
+            <summary>
+            Sets the quiet writer used for file output
+            </summary>
+            <param name="fileStream">the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This implementation of <see cref="M:SetQWForFiles(Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>
+            over the <paramref name="fileStream"/> and passes it to the 
+            <see cref="M:SetQWForFiles(TextWriter)"/> method.
+            </para>
+            <para>
+            This method can be overridden by sub classes that want to wrap the
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <param name="writer">the writer over the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This method can be overridden by sub classes that want to
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
+            <summary>
+            Flag to indicate if we should append to the file
+            or overwrite the file. The default is to append.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_fileName">
+            <summary>
+            The name of the log file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_encoding">
+            <summary>
+            The encoding to use for the file stream.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_stream">
+            <summary>
+            The stream to log to. Has added locking semantics
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">
+            <summary>
+            The locking model to use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.declaringType">
+            <summary>
+            The fully qualified type of the FileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.File">
+            <summary>
+            Gets or sets the path to the file that logging will be written to.
+            </summary>
+            <value>
+            The path to the file that logging will be written to.
+            </value>
+            <remarks>
+            <para>
+            If the path is relative it is taken as relative from 
+            the application base directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">
+            <summary>
+            Gets or sets a flag that indicates whether the file should be
+            appended to or overwritten.
+            </summary>
+            <value>
+            Indicates whether the file should be appended to or overwritten.
+            </value>
+            <remarks>
+            <para>
+            If the value is set to false then the file will be overwritten, if 
+            it is set to true then the file will be appended to.
+            </para>
+            The default value is true.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>
+            which is the encoding for the system's current ANSI code page.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModel">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </para>
+            <para>
+            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"/> .
+            The first locks the file from the start of logging to the end, the 
+            second locks only for the minimal amount of time when logging each message
+            and the last synchronizes processes using a named system wide Mutex.
+            </para>
+            <para>
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingStream">
+            <summary>
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> 
+            to manage access to an underlying resource.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
+            <summary>
+            True asynchronous writes are not supported, the implementation forces a synchronous write.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LogException">
+            <summary>
+            Exception base type for log4net.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with
+            the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">
+            <summary>
+            Locking model base class
+            </summary>
+            <remarks>
+            <para>
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the output file
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CreateStream(System.String,System.Boolean,System.IO.FileShare)">
+            <summary>
+            Helper method that creates a FileStream under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            <para>
+            Typically called during OpenFile or AcquireLock. 
+            </para>
+            <para>
+            If the directory portion of the <paramref name="filename"/> does not exist, it is created
+            via Directory.CreateDirecctory.
+            </para>
+            </remarks>
+            <param name="filename"></param>
+            <param name="append"></param>
+            <param name="fileShare"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseStream(System.IO.Stream)">
+            <summary>
+            Helper method to close <paramref name="stream"/> under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            Does not set <paramref name="stream"/> to null.
+            </remarks>
+            <param name="stream"></param>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </summary>
+            <value>
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </value>
+            <remarks>
+            <para>
+            The file appender this locking model is attached to and working on
+            behalf of.
+            </para>
+            <para>
+            The file appender is used to locate the security context and the error handler to use.
+            </para>
+            <para>
+            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
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">
+            <summary>
+            Hold an exclusive lock on the output file
+            </summary>
+            <remarks>
+            <para>
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. 
+            Maintains an exclusive lock on the file during this time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Does nothing. The lock will be released when the file is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">
+            <summary>
+            Acquires the file lock for each write
+            </summary>
+            <remarks>
+            <para>
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, 
+            thus holding the lock for the minimal amount of time. This method of locking
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows 
+            other processes to move/delete the log file whilst logging continues.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Prepares to open the file when the first message is logged.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.InterProcessLock">
+            <summary>
+            Provides cross-process file locking.
+            </summary>
+            <author>Ron Grabowski</author>
+            <author>Steve Wranovsky</author>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/>,
+            -<see cref="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock">
+            <summary>
+            Releases the lock and allows others to acquire a lock.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ForwardingAppender">
+            <summary>
+            This appender forwards logging events to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The forwarding appender can be used to specify different thresholds
+            and filters for the same appender at different locations within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Forward the logging event to the attached appenders 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Forward the logging events to the attached appenders 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging events to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender">
+            <summary>
+            Logs events to a local syslog service.
+            </summary>
+            <remarks>
+            <note>
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.
+            If these functions are not available on the local system then this appender will not work!
+            </note>
+            <para>
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and 
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.
+            </para>
+            <para>
+            This appender talks to a local syslog service. If you need to log to a remote syslog
+            daemon and you cannot configure your local syslog service to do this you may be
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write 
+            to a local syslog service.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">
+            <summary>
+            Close the syslog when the appender is closed
+            </summary>
+            <remarks>
+            <para>
+            Close the syslog when the appender is closed
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">
+            <summary>
+            Marshaled handle to the identity string. We have to hold on to the
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the
+            pointer to the ident and dereference it for each log message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">
+            <summary>
+            Open connection to system logger.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">
+            <summary>
+            Generate a log message.
+            </summary>
+            <remarks>
+            <para>
+            The libc syslog method takes a format string and a variable argument list similar
+            to the classic printf function. As this type of vararg list is not supported
+            by C# we need to specify the arguments explicitly. Here we have specified the
+            format string with a single message argument. The caller must set the format 
+            string to <c>"%s"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">
+            <summary>
+            Close descriptor used to write to system logger.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The log4net Level maps to a syslog severity using the
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facility defines which subsystem the logging comes from.
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender">
+            <summary>
+            Appends colorful logging events to the console, using the .NET 2
+            built-in capabilities.
+            </summary>
+            <remarks>
+            <para>
+            ManagedColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            When configuring the colored console appender, mappings should be
+            specified to map logging levels to colors. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="DarkRed"/>
+            	<backColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="WARN"/>
+            	<foreColor value="Yellow"/>
+            </mapping>
+            <mapping>
+            	<level value="INFO"/>
+            	<foreColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<foreColor value="Blue"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level while
+            ForeColor and BackColor are the values of <see cref="T:System.ConsoleColor"/>
+            enumeration.
+            </para>
+            <para>
+            Based on the ColoredConsoleAppender
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+            <author>Pavlos Touboulidis</author>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.AddMapping(log4net.Appender.ManagedColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.MemoryAppender">
+            <summary>
+            Stores logging events in an array.
+            </summary>
+            <remarks>
+            <para>
+            The memory appender stores all the logging events
+            that are appended in an in-memory array.
+            </para>
+            <para>
+            Use the <see cref="M:PopAllEvents()"/> method to get
+            and clear the current list of events that have been appended.
+            </para>
+            <para>
+            Use the <see cref="M:GetEvents()"/> method to get the current
+            list of events that have been appended.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            <para>
+            Use the <see cref="M:Clear()"/> method to clear the
+            current list of events.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            </remarks>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">
+            <summary>
+            Gets the events that have been logged.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Clear">
+            <summary>
+            Clear the list of events
+            </summary>
+            <remarks>
+            Clear the list of events
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.PopAllEvents">
+            <summary>
+            Gets the events that have been logged and clears the list of events.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged and clears the list of events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
+            <summary>
+            The list of events that have been appended.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating whether only part of the logging event 
+            data should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the event 
+            data to be fixed and stored in the appender, hereby improving performance. 
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(bool)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.Fix">
+            <summary>
+            Gets or sets the fields that will be fixed in the event
+            </summary>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.NetSendAppender">
+            <summary>
+            Logs entries by sending network messages using the 
+            <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> native function.
+            </summary>
+            <remarks>
+            <para>
+            You can send messages only to names that are active 
+            on the network. If you send the message to a user name, 
+            that user must be logged on and running the Messenger 
+            service to receive the message.
+            </para>
+            <para>
+            The receiver will get a top most window displaying the 
+            messages one at a time, therefore this appender should 
+            not be used to deliver a high volume of messages.
+            </para>
+            <para>
+            The following table lists some possible uses for this appender :
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Action</term>
+                    <description>Property Value(s)</description>
+                </listheader>
+                <item>
+                    <term>Send a message to a user account on the local machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a user account on a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the remote machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a domain user account</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of a domain controller | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to all the names in a workgroup or domain</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;workgroup name | domain name&gt;*
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message from the local machine to a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;name of the remote machine&gt;
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            <b>Note :</b> security restrictions apply for sending 
+            network messages, see <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> 
+            for more information.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            An example configuration section to log information 
+            using this appender from the local machine, named 
+            LOCAL_PC, to machine OPERATOR_PC :
+            </para>
+            <code lang="XML" escaped="true">
+            <appender name="NetSendAppender_Operator" type="log4net.Appender.NetSendAppender">
+                <server value="LOCAL_PC"/>
+                <recipient value="OPERATOR_PC"/>
+                <layout type="log4net.Layout.PatternLayout" value="%-5p %c [%x] - %m%n"/>
+            </appender>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_server">
+            <summary>
+            The DNS or NetBIOS name of the server on which the function is to execute.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_sender">
+            <summary>
+            The sender of the network message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_recipient">
+            <summary>
+            The message alias to which the message should be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.#ctor">
+            <summary>
+            Initializes the appender.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was not specified.</exception>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using a network message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)">
+            <summary>
+            Sends a buffer of information to a registered message alias.
+            </summary>
+            <param name="serverName">The DNS or NetBIOS name of the server on which the function is to execute.</param>
+            <param name="msgName">The message alias to which the message buffer should be sent</param>
+            <param name="fromName">The originator of the message.</param>
+            <param name="buffer">The message text.</param>
+            <param name="bufferSize">The length, in bytes, of the message text.</param>
+            <remarks>
+            <para>
+            The following restrictions apply for sending network messages:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Platform</term>
+                    <description>Requirements</description>
+                </listheader>
+                <item>
+                    <term>Windows NT</term>
+                    <description>
+                        <para>
+                        No special group membership is required to send a network message.
+                        </para>
+                        <para>
+                        Admin, Accounts, Print, or Server Operator group membership is required to 
+                        successfully send a network message on a remote server.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Windows 2000 or later</term>
+                    <description>
+                        <para>
+                        If you send a message on a domain controller that is running Active Directory, 
+                        access is allowed or denied based on the access control list (ACL) for the securable 
+                        object. The default ACL permits only Domain Admins and Account Operators to send a network message. 
+                        </para>
+                        <para>
+                        On a member server or workstation, only Administrators and Server Operators can send a network message. 
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            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>.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is zero.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Sender">
+            <summary>
+            Gets or sets the sender of the message.
+            </summary>
+            <value>
+            The sender of the message.
+            </value>
+            <remarks>
+            If this property is not specified, the message is sent from the local computer.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Recipient">
+            <summary>
+            Gets or sets the message alias to which the message should be sent.
+            </summary>
+            <value>
+            The recipient of the message.
+            </value>
+            <remarks>
+            This property should always be specified in order to send a message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Server">
+            <summary>
+            Gets or sets the DNS or NetBIOS name of the remote server on which the function is to execute.
+            </summary>
+            <value>
+            DNS or NetBIOS name of the remote server on which the function is to execute.
+            </value>
+            <remarks>
+            <para>
+            For Windows NT 4.0 and earlier, the string should begin with \\.
+            </para>
+            <para>
+            If this property is not specified, the local computer is used. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.OutputDebugStringAppender">
+            <summary>
+            Appends log events to the OutputDebugString system.
+            </summary>
+            <remarks>
+            <para>
+            OutputDebugStringAppender appends log events to the
+            OutputDebugString system.
+            </para>
+            <para>
+            The string is passed to the native <c>OutputDebugString</c> 
+            function.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.OutputDebugStringAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the output debug string API
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the output debug string API
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">
+            <summary>
+            Stub for OutputDebugString native method
+            </summary>
+            <param name="message">the string to output</param>
+            <remarks>
+            <para>
+            Stub for OutputDebugString native method
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.OutputDebugStringAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender">
+            <summary>
+            Logs events to a remote syslog daemon.
+            </summary>
+            <remarks>
+            <para>
+            The BSD syslog protocol is used to remotely log to
+            a syslog daemon. The syslogd listens for for messages
+            on UDP port 514.
+            </para>
+            <para>
+            The syslog UDP protocol is not authenticated. Most syslog daemons
+            do not accept remote log messages because of the security implications.
+            You may be able to use the LocalSyslogAppender to talk to a local
+            syslog service.
+            </para>
+            <para>
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.
+            This appender generates what the RFC calls an "Original Device Message",
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation
+            this format of message will be accepted by all current syslog daemon
+            implementations. The daemon will attach the current time and the source
+            hostname or IP address to any messages received.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Appender.UdpAppender">
+             <summary>
+             Sends logging events as connectionless UDP datagrams to a remote host or a 
+             multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.
+             </summary>
+             <remarks>
+             <para>
+             UDP guarantees neither that messages arrive, nor that they arrive in the correct order.
+             </para>
+             <para>
+             To view the logging results, a custom application can be developed that listens for logging 
+             events.
+             </para>
+             <para>
+             When decoding events send via this appender remember to use the same encoding
+             to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>
+             property to specify the encoding to use.
+             </para>
+             </remarks>
+             <example>
+             This example shows how to log receive logging events that are sent 
+             on IP address 244.0.0.1 and port 8080 to the console. The event is 
+             encoded in the packet as a unicode string and it is decoded as such. 
+             <code lang="C#">
+             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+             UdpClient udpClient;
+             byte[] buffer;
+             string loggingEvent;
+             
+             try 
+             {
+                 udpClient = new UdpClient(8080);
+                 
+                 while(true) 
+                 {
+                     buffer = udpClient.Receive(ref remoteEndPoint);
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
+                     Console.WriteLine(loggingEvent);
+                 }
+             } 
+             catch(Exception e) 
+             {
+                 Console.WriteLine(e.ToString());
+             }
+             </code>
+             <code lang="Visual Basic">
+             Dim remoteEndPoint as IPEndPoint
+             Dim udpClient as UdpClient
+             Dim buffer as Byte()
+             Dim loggingEvent as String
+             
+             Try 
+                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
+                 udpClient = new UdpClient(8080)
+            
+                 While True
+                     buffer = udpClient.Receive(ByRef remoteEndPoint)
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
+                     Console.WriteLine(loggingEvent)
+                 Wend
+             Catch e As Exception
+                 Console.WriteLine(e.ToString())
+             End Try
+             </code>
+             <para>
+             An example configuration section to log information using this appender to the 
+             IP 224.0.0.1 on port 8080:
+             </para>
+             <code lang="XML" escaped="true">
+             <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
+                 <remoteAddress value="224.0.0.1"/>
+                 <remotePort value="8080"/>
+                 <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>
+             </appender>
+             </code>
+             </example>
+             <author>Gert Driesen</author>
+             <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or 
+            an invalid remote or local TCP port number was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>
+            <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>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using an UDP datagram.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.OnClose">
+            <summary>
+            Closes the UDP connection and releases all resources associated with 
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed 
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">
+            <summary>
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.
+            </summary>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the 
+            port number from which you intend to communicate.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">
+            <summary>
+            The IP address of the remote host or multicast group to which 
+            the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">
+            <summary>
+            The TCP port number of the remote host or multicast group to 
+            which the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">
+            <summary>
+            The cached remote endpoint to which the logging events will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">
+            <summary>
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_client">
+            <summary>
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the 
+            logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">
+            <summary>
+            The encoding to use for the packet.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">
+            <summary>
+            Gets or sets the IP address of the remote host or multicast group to which
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            The IP address of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            <para>
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so
+            it is possible to use multicasts in an Internet scenario as long as your network provider 
+            supports multicasting.
+            </para>
+            <para>
+            Hosts that want to receive particular multicast messages must register their interest by joining
+            the multicast group.  Multicast messages are not sent to networks where no host has joined
+            the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
+            them from normal host addresses, allowing nodes to easily detect if a message is of interest.
+            </para>
+            <para>
+            Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>IP Address</term>
+                    <description>Description</description>
+                </listheader>
+                <item>
+                    <term>224.0.0.1</term>
+                    <description>
+                        <para>
+                        Sends a message to all system on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.2</term>
+                    <description>
+                        <para>
+                        Sends a message to all routers on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.12</term>
+                    <description>
+                        <para>
+                        The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            A complete list of actually reserved multicast addresses and their owners in the ranges
+            defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
+            </para>
+            <para>
+            The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
+            addresses.  These addresses can be reused with other local groups.  Routers are typically 
+            configured with filters to prevent multicast traffic in this range from flowing outside
+            of the local network.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemotePort">
+            <summary>
+            Gets or sets the TCP port number of the remote host or multicast group to which 
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will send messages to this TCP port number
+            on the remote host or multicast group.
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.LocalPort">
+            <summary>
+            Gets or sets the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </value>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will bind to this port for sending messages.
+            </para>
+            <para>
+            Setting the value to 0 (the default) will cause the udp client not to bind to
+            a local port.
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Client">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.UdpAppender"/> creates a <see cref="T:System.Net.Sockets.UdpClient"/> to send logging events 
+            over a network.  Classes deriving from <see cref="T:log4net.Appender.UdpAppender"/> can use this
+            property to get or set this <see cref="T:System.Net.Sockets.UdpClient"/>.  Use the underlying <see cref="T:System.Net.Sockets.UdpClient"/>
+            returned from <see cref="P:log4net.Appender.UdpAppender.Client"/> if you require access beyond that which 
+            <see cref="T:log4net.Appender.UdpAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteEndPoint">
+            <summary>
+            Gets or sets the cached remote endpoint to which the logging events should be sent.
+            </summary>
+            <value>
+            The cached remote endpoint to which the logging events will be sent.
+            </value>
+            <remarks>
+            The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method will initialize the remote endpoint 
+            with the values of the <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> and <see cref="P:log4net.Appender.UdpAppender.RemotePort"/>
+            properties.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.DefaultSyslogPort">
+            <summary>
+            Syslog port 514
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class is set up to write 
+            to a remote syslog daemon.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.AddMapping(log4net.Appender.RemoteSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity"/> mapping to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to syslog severity mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GeneratePriority(log4net.Appender.RemoteSyslogAppender.SyslogFacility,log4net.Appender.RemoteSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+            <remarks>
+            <para>
+            Generate a syslog priority.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The syslog severities.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facilities
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender">
+            <summary>
+            Delivers logging events to a remote logging sink. 
+            </summary>
+            <remarks>
+            <para>
+            This Appender is designed to deliver events to a remote sink. 
+            That is any object that implements the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface. It delivers the events using .NET remoting. The
+            object to deliver events to is specified by setting the
+            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.</para>
+            <para>
+            The RemotingAppender buffers events before sending them. This allows it to 
+            make more efficient use of the remoting infrastructure.</para>
+            <para>
+            Once the buffer is full the events are still not sent immediately. 
+            They are scheduled to be sent using a pool thread. The effect is that 
+            the send occurs asynchronously. This is very important for a 
+            number of non obvious reasons. The remoting infrastructure will 
+            flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.</para>
+            <para>
+            Because the events are sent asynchronously using pool threads it is possible to close 
+            this appender before all the queued events have been sent.
+            When closing the appender attempts to wait until all the queued events have been sent, but 
+            this will timeout after 30 seconds regardless.</para>
+            <para>
+            If this appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for. If the runtime terminates the threads before
+            the queued events have been sent then they will be lost. To ensure that all events
+            are sent the appender must be closed before the application exits. See 
+            <see cref="M:log4net.Core.LoggerManager.Shutdown"/> for details on how to shutdown
+            log4net programmatically.</para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemotingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            The events are not sent immediately. They are scheduled to be sent
+            using a pool thread. The effect is that the send occurs asynchronously.
+            This is very important for a number of non obvious reasons. The remoting
+            infrastructure will flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.
+            </remarks>
+            <param name="events">The events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.OnClose">
+            <summary>
+            Override base class close.
+            </summary>
+            <remarks>
+            <para>
+            This method waits while there are queued work items. The events are
+            sent asynchronously using <see cref="T:System.Threading.ThreadPool"/> work items. These items
+            will be sent once a thread pool thread is available to send them, therefore
+            it is possible to close the appender before all the queued events have been
+            sent.</para>
+            <para>
+            This method attempts to wait until all the queued events have been sent, but this 
+            method will timeout after 30 seconds regardless.</para>
+            <para>
+            If the appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.BeginAsyncSend">
+            <summary>
+            A work item is being queued into the thread pool
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.EndAsyncSend">
+            <summary>
+            A work item from the thread pool has completed
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBufferCallback(System.Object)">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            This method is designed to be used with the <see cref="T:System.Threading.ThreadPool"/>.
+            This method expects to be passed an array of <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the state param.
+            </remarks>
+            <param name="state">the logging events to send</param>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">
+            <summary>
+            The URL of the remote sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">
+            <summary>
+            The local proxy (.NET remoting) for the remote logging sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_queuedCallbackCount">
+            <summary>
+            The number of queued callbacks currently waiting or executing
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_workQueueEmptyEvent">
+            <summary>
+            Event used to signal when there are no queued work items
+            </summary>
+            <remarks>
+            This event is set when there are no queued work items. In this
+            state it is safe to close the appender.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemotingAppender.Sink">
+            <summary>
+            Gets or sets the URL of the well-known object that will accept 
+            the logging events.
+            </summary>
+            <value>
+            The well-known URL of the remote sink.
+            </value>
+            <remarks>
+            <para>
+            The URL of the remoting sink that will accept logging events.
+            The sink must implement the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink">
+            <summary>
+            Interface used to deliver <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            This interface must be implemented by a remoting sink
+            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used
+            to deliver logging events to the sink.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.IRemoteLoggingSink.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Delivers logging events to the remote sink
+            </summary>
+            <param name="events">Array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers logging events to the remote sink
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender">
+            <summary>
+            Appender that rolls log files based on size or date or both.
+            </summary>
+            <remarks>
+            <para>
+            RollingFileAppender can roll log files based on size or date or both
+            depending on the setting of the <see cref="P:log4net.Appender.RollingFileAppender.RollingStyle"/> property.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Size"/> the log file will be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Date"/> the log file will be rolled
+            once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/> the log file will be
+            rolled once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed, but within a date boundary the file will also be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> the log file will be rolled when
+            the appender is configured. This effectively means that the log file can be
+            rolled once per program execution.
+            </para>
+            <para>
+            A of few additional optional features have been added:
+            <list type="bullet">
+            <item>Attach date pattern for current log file <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/></item>
+            <item>Backup number increments for newer files <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/></item>
+            <item>Infinite number of backups by file size <see cref="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups"/></item>
+            </list>
+            </para>
+            
+            <note>
+            <para>
+            For large or infinite numbers of backup files a <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> 
+            greater than zero is highly recommended, otherwise all the backup files need
+            to be renamed each time a new backup is created.
+            </para>
+            <para>
+            When Date/Time based rolling is used setting <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> 
+            to <see langword="true"/> will reduce the number of file renamings to few or none.
+            </para>
+            </note>
+            
+            <note type="caution">
+            <para>
+            Changing <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> or <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> without clearing
+            the log file directory of backup files will cause unexpected and unwanted side effects.  
+            </para>
+            </note>
+            
+            <para>
+            If Date/Time based rolling is enabled this appender will attempt to roll existing files
+            in the directory without a Date/Time tag based on the last write date of the base log file.
+            The appender only rolls the log file when a message is logged. If Date/Time based rolling 
+            is enabled then the appender will not roll the log file at the Date/Time boundary but
+            at the point when the next message is logged after the boundary has been crossed.
+            </para>
+            
+            <para>
+            The <see cref="T:log4net.Appender.RollingFileAppender"/> extends the <see cref="T:log4net.Appender.FileAppender"/> and
+            has the same behavior when opening the log file.
+            The appender will first try to open the file for writing when <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            When rolling a backup file necessitates deleting an older backup file the
+            file to be deleted is moved to a temporary name before being deleted.
+            </para>
+            
+            <note type="caution">
+            <para>
+            A maximum number of backup files when rolling on date/time boundaries is not supported.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Edward Smit</author>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RollingFileAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Finalize">
+            <summary>
+            Cleans up all resources used by this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.declaringType">
+            <summary>
+            The fully qualified type of the RollingFileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <remarks>
+            This method can be overridden by sub classes.
+            </remarks>
+            <param name="writer">the writer to set</param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write out a logging event.
+            </summary>
+            <param name="loggingEvent">the event to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Write out an array of logging events.
+            </summary>
+            <param name="loggingEvents">the events to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.AdjustFileBeforeAppend">
+            <summary>
+            Performs any required rolling before outputting the next event
+            </summary>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Creates and opens the file for logging.  If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/>
+            is false then the fully qualified name is determined and used.
+            </summary>
+            <param name="fileName">the name of the file to open</param>
+            <param name="append">true to append to existing file</param>
+            <remarks>
+            <para>This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetNextOutputFileName(System.String)">
+            <summary>
+            Get the current output file name
+            </summary>
+            <param name="fileName">the base file name</param>
+            <returns>the output file name</returns>
+            <remarks>
+            The output file name is based on the base fileName specified.
+            If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> is set then the output 
+            file name is the same as the base file passed in. Otherwise
+            the output file depends on the date pattern, on the count
+            direction or both.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DetermineCurSizeRollBackups">
+            <summary>
+            Determines curSizeRollBackups (only within the current roll point)
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">
+            <summary>
+            Generates a wildcard pattern that can be used to find all files
+            that are similar to the base file name.
+            </summary>
+            <param name="baseFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">
+            <summary>
+            Builds a list of filenames for all files matching the base filename plus a file
+            pattern.
+            </summary>
+            <param name="baseFilePath"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">
+            <summary>
+            Initiates a roll over if needed for crossing a date boundary since the last run.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">
+            <summary>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            </summary>
+            <remarks>
+            <para>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            The following is done
+            <list type="bullet">
+            <item>determine curSizeRollBackups (only within the current roll point)</item>
+            <item>initiates a roll over if needed for crossing a date boundary since the last run.</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">
+            <summary>
+            Does the work of bumping the 'current' file counter higher
+            to the highest count when an incremental file name is seen.
+            The highest count is either the first file (when count direction
+            is greater than 0) or the last file (when count direction less than 0).
+            In either case, we want to know the highest count that is present.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="curFileName"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetBackUpIndex(System.String)">
+            <summary>
+            Attempts to extract a number from the end of the file name that indicates
+            the number of the times the file has been rolled over.
+            </summary>
+            <remarks>
+            Certain date pattern extensions like yyyyMMdd will be parsed as valid backup indexes.
+            </remarks>
+            <param name="curFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">
+            <summary>
+            Takes a list of files and a base file name, and looks for 
+            'incremented' versions of the base file.  Bumps the max
+            count up to the highest count seen.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="arrayFiles"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod(System.String)">
+            <summary>
+            Calculates the RollPoint for the datePattern supplied.
+            </summary>
+            <param name="datePattern">the date pattern to calculate the check period for</param>
+            <returns>The RollPoint that is most accurate for the date pattern supplied</returns>
+            <remarks>
+            Essentially the date pattern is examined to determine what the
+            most suitable roll point is. The roll point chosen is the roll point
+            with the smallest period that can be detected using the date pattern
+            supplied. i.e. if the date pattern only outputs the year, month, day 
+            and hour then the smallest roll point that can be detected would be
+            and hourly roll point as minutes could not be detected.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Sets initial conditions including date/time roll over information, first check,
+            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize
+            the current number of backups.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.CombinePath(System.String,System.String)">
+            <summary>
+            
+            </summary>
+            <param name="path1"></param>
+            <param name="path2">.1, .2, .3, etc.</param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime(System.Boolean)">
+            <summary>
+            Rollover the file(s) to date/time tagged file(s).
+            </summary>
+            <param name="fileIsOpen">set to true if the file to be rolled is currently open</param>
+            <remarks>
+            <para>
+            Rollover the file(s) to date/time tagged file(s).
+            Resets curSizeRollBackups. 
+            If fileIsOpen is set then the new file is opened (through SafeOpenFile).
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">
+            <summary>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>.
+            </summary>
+            <param name="fromFile">Name of existing file to roll.</param>
+            <param name="toFile">New name for file.</param>
+            <remarks>
+            <para>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. It
+            also checks for existence of target file and deletes if it does.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.FileExists(System.String)">
+            <summary>
+            Test if a file exists at a specified path
+            </summary>
+            <param name="path">the path to the file</param>
+            <returns>true if the file exists</returns>
+            <remarks>
+            <para>
+            Test if a file exists at a specified path
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">
+            <summary>
+            Deletes the specified file if it exists.
+            </summary>
+            <param name="fileName">The file to delete.</param>
+            <remarks>
+            <para>
+            Delete a file if is exists.
+            The file is first moved to a new filename then deleted.
+            This allows the file to be removed even when it cannot
+            be deleted, but it still can be moved.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">
+            <summary>
+            Implements file roll base on file size.
+            </summary>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. Moreover, <c>File</c> is
+            renamed <c>File.1</c> and closed.
+            </para>
+            <para>
+            A new file is created to receive further log output.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverRenameFiles(System.String)">
+            <summary>
+            Implements file roll.
+            </summary>
+            <param name="baseFileName">the base name to rename</param>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. 
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            <para>
+            This is called by <see cref="M:log4net.Appender.RollingFileAppender.RollOverSize"/> to rename the files.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">
+            <summary>
+            Get the start time of the next window for the current rollpoint
+            </summary>
+            <param name="currentDateTime">the current date</param>
+            <param name="rollPoint">the type of roll point we are working with</param>
+            <returns>the start time for the next roll point an interval after the currentDateTime date</returns>
+            <remarks>
+            <para>
+            Returns the date of the next roll point after the currentDateTime date passed to the method.
+            </para>
+            <para>
+            The basic strategy is to subtract the time parts that are less significant
+            than the rollpoint from the current time. This should roll the time back to
+            the start of the time window for the current rollpoint. Then we add 1 window
+            worth of time and get the start time of the next window for the rollpoint.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">
+            <summary>
+            This object supplies the current date/time.  Allows test code to plug in
+            a method to control this class when testing date/time based rolling. The default
+            implementation uses the underlying value of DateTime.Now.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">
+            <summary>
+            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> 
+            meaning daily rollover.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">
+            <summary>
+            The actual formatted filename that is currently being written to
+            or will be the file transferred to on roll over
+            (based on staticLogFileName).
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">
+            <summary>
+            The timestamp when we shall next recompute the filename.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_now">
+            <summary>
+            Holds date of last roll over
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">
+            <summary>
+            The type of rolling done
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">
+            <summary>
+            The default maximum file size is 10MB
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">
+            <summary>
+            There is zero backup files by default
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">
+            <summary>
+            How many sized based backups have been made so far
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">
+            <summary>
+            The rolling file count direction. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">
+            <summary>
+            The rolling mode used in this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">
+            <summary>
+            Cache flag set if we are rolling by date.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">
+            <summary>
+            Cache flag set if we are rolling by size.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">
+            <summary>
+            Value indicating whether to always log to the same file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_preserveLogFileNameExtension">
+            <summary>
+            Value indicating whether to preserve the file name extension when rolling.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">
+            <summary>
+            FileName provided in configuration.  Used for rolling properly
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_mutexForRolling">
+            <summary>
+            A mutex that is used to lock rolling of files.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DateTimeStrategy">
+            <summary>
+            Gets or sets the strategy for determining the current date and time. The default
+            implementation is to use LocalDateTime which internally calls through to DateTime.Now. 
+            DateTime.UtcNow may be used on frameworks newer than .NET 1.0 by specifying
+            <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </summary>
+            <value>
+            An implementation of the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> interface which returns the current date and time.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> used to return the current date and time.
+            </para>
+            <para>
+            There are two built strategies for determining the current date and time, 
+            <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>
+            and <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </para>
+            <para>
+            The default strategy is <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">
+            <summary>
+            Gets or sets the date pattern to be used for generating file names
+            when rolling over on date.
+            </summary>
+            <value>
+            The date pattern to be used for generating file names when rolling 
+            over on date.
+            </value>
+            <remarks>
+            <para>
+            Takes a string in the same format as expected by 
+            <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.
+            </para>
+            <para>
+            This property determines the rollover schedule when rolling over
+            on date.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">
+            <summary>
+            Gets or sets the maximum number of backup files that are kept before
+            the oldest is erased.
+            </summary>
+            <value>
+            The maximum number of backup files that are kept before the oldest is
+            erased.
+            </value>
+            <remarks>
+            <para>
+            If set to zero, then there will be no backup files and the log file 
+            will be truncated when it reaches <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  
+            </para>
+            <para>
+            If a negative number is supplied then no deletions will be made.  Note 
+            that this could result in very slow performance as a large number of 
+            files are rolled over unless <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> is used.
+            </para>
+            <para>
+            The maximum applies to <b>each</b> time based group of files and 
+            <b>not</b> the total.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size in bytes that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except
+            that it is required for differentiating the setter taking a
+            <see cref="T:System.Int64"/> argument from the setter taking a <see cref="T:System.String"/> 
+            argument.
+            </para>
+            <para>
+            The default maximum file size is 10MB (10*1024*1024).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property allows you to specify the maximum size with the
+            suffixes "KB", "MB" or "GB" so that the size is interpreted being 
+            expressed respectively in kilobytes, megabytes or gigabytes. 
+            </para>
+            <para>
+            For example, the value "10KB" will be interpreted as 10240 bytes.
+            </para>
+            <para>
+            The default maximum file size is 10MB.
+            </para>
+            <para>
+            If you have the option to set the maximum file size programmatically
+            consider using the <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/> property instead as this
+            allows you to set the size in bytes as a <see cref="T:System.Int64"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">
+            <summary>
+            Gets or sets the rolling file count direction. 
+            </summary>
+            <value>
+            The rolling file count direction.
+            </value>
+            <remarks>
+            <para>
+            Indicates if the current file is the lowest numbered file or the
+            highest numbered file.
+            </para>
+            <para>
+            By default newer files have lower numbers (<see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &lt; 0),
+            i.e. log.1 is most recent, log.5 is the 5th backup, etc...
+            </para>
+            <para>
+            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 does the opposite i.e.
+            log.1 is the first backup made, log.5 is the 5th backup made, etc.
+            For infinite backups use <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 to reduce 
+            rollover costs.
+            </para>
+            <para>The default file count direction is -1.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">
+            <summary>
+            Gets or sets the rolling style.
+            </summary>
+            <value>The rolling style.</value>
+            <remarks>
+            <para>
+            The default rolling style is <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/>.
+            </para>
+            <para>
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> this appender's
+            <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is set to <c>false</c>, otherwise
+            the appender would append to a single file rather than rolling
+            the file each time it is opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.PreserveLogFileNameExtension">
+            <summary>
+            Gets or sets a value indicating whether to preserve the file name extension when rolling.
+            </summary>
+            <value>
+            <c>true</c> if the file name extension should be preserved.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is rolled to file.log.yyyy-MM-dd or file.log.curSizeRollBackup.
+            However, under Windows the new file name will loose any program associations as the
+            extension is changed. Optionally file.log can be renamed to file.yyyy-MM-dd.log or
+            file.curSizeRollBackup.log to maintain any program associations.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">
+            <summary>
+            Gets or sets a value indicating whether to always log to
+            the same file.
+            </summary>
+            <value>
+            <c>true</c> if always should be logged to the same file, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is always the current file.  Optionally
+            file.log.yyyy-mm-dd for current formatted datePattern can by the currently
+            logging file (or file.log.curSizeRollBackup or even
+            file.log.yyyy-mm-dd.curSizeRollBackup).
+            </para>
+            <para>
+            This will make time based rollovers with a large number of backups 
+            much faster as the appender it won't have to rename all the backups!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">
+            <summary>
+            Style of rolling to use
+            </summary>
+            <remarks>
+            <para>
+            Style of rolling to use
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Once">
+            <summary>
+            Roll files once per program execution
+            </summary>
+            <remarks>
+            <para>
+            Roll files once per program execution.
+            Well really once each time this appender is
+            configured.
+            </para>
+            <para>
+            Setting this option also sets <c>AppendToFile</c> to
+            <c>false</c> on the <c>RollingFileAppender</c>, otherwise
+            this appender would just be a normal file appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">
+            <summary>
+            Roll files based only on the size of the file
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">
+            <summary>
+            Roll files based only on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">
+            <summary>
+            Roll files based on both the size and date of the file
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">
+            <summary>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </summary>
+            <remarks>
+            <para>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.InvalidRollPoint">
+            <summary>
+            Roll the log not based on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMinute">
+            <summary>
+            Roll the log for each minute
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfHour">
+            <summary>
+            Roll the log for each hour
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HalfDay">
+            <summary>
+            Roll the log twice a day (midday and midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfDay">
+            <summary>
+            Roll the log each day (midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfWeek">
+            <summary>
+            Roll the log each week
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMonth">
+            <summary>
+            Roll the log each month
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.IDateTime">
+            <summary>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            </summary>
+            <remarks>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            Used primarily to allow test classes to plug themselves in so they can
+            supply test date/times.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.IDateTime.Now">
+            <summary>
+            Gets the <i>current</i> time.
+            </summary>
+            <value>The <i>current</i> time.</value>
+            <remarks>
+            <para>
+            Gets the <i>current</i> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.LocalDateTime">
+            <summary>
+            Default implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.LocalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.UniversalDateTime">
+            <summary>
+            Implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time as the coordinated universal time (UTC).
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.UniversalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender">
+            <summary>
+            Send an e-mail when a specific logging event occurs, typically on errors 
+            or fatal errors.
+            </summary>
+            <remarks>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            <note type="caution">
+            Authentication and setting the server Port are only available on the MS .NET 1.1 runtime.
+            For these features to be enabled you need to ensure that you are using a version of
+            the log4net assembly that is built against the MS .NET 1.1 framework and that you are
+            running the your application on the MS .NET 1.1 runtime. On all other platforms only sending
+            unauthenticated messages to a server listening on port 25 (the default) is supported.
+            </note>
+            <para>
+            Authentication is supported by setting the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property to
+            either <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> or <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>.
+            If using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> authentication then the <see cref="P:log4net.Appender.SmtpAppender.Username"/>
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> properties must also be set.
+            </para>
+            <para>
+            To set the SMTP server port use the <see cref="P:log4net.Appender.SmtpAppender.Port"/> property. The default port is 25.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendEmail(System.String)">
+            <summary>
+            Send the email message
+            </summary>
+            <param name="messageBody">the body text to include in the mail</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.MaybeTrimSeparators(System.String)">
+            <summary>
+              trims leading and trailing commas or semicolons
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.To">
+            <summary>
+            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).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Cc">
+            <summary>
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses 
+            that will be carbon copied (use semicolon on .NET 1.1 and comma for later versions).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Bcc">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses
+            that will be blind carbon copied.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of recipient e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SmtpHost">
+            <summary>
+            Gets or sets the name of the SMTP relay mail server to use to send 
+            the e-mail messages.
+            </summary>
+            <value>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </value>
+            <remarks>
+            <para>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.LocationInfo">
+            <summary>
+            Obsolete
+            </summary>
+            <remarks>
+            Use the BufferingAppenderSkeleton Fix methods instead 
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Authentication">
+            <summary>
+            The mode to use to authentication with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            Valid Authentication mode values are: <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>, 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, and <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>. 
+            The default value is <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>. When using 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> you must specify the <see cref="P:log4net.Appender.SmtpAppender.Username"/> 
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> to use to authenticate.
+            When using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/> the Windows credentials for the current
+            thread, if impersonating, or the process will be used to authenticate. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Username">
+            <summary>
+            The username to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the username will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Password">
+            <summary>
+            The password to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the password will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Port">
+            <summary>
+            The port on which the SMTP server is listening
+            </summary>
+            <remarks>
+            <note type="caution">Server Port is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            The port on which the SMTP server is listening. The default
+            port is <c>25</c>. The Port can only be changed when running on
+            the MS .NET 1.1 runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Priority">
+            <summary>
+            Gets or sets the priority of the e-mail message
+            </summary>
+            <value>
+            One of the <see cref="T:System.Net.Mail.MailPriority"/> values.
+            </value>
+            <remarks>
+            <para>
+            Sets the priority of the e-mails generated by this
+            appender. The default priority is <see cref="F:System.Net.Mail.MailPriority.Normal"/>.
+            </para>
+            <para>
+            If you are using this appender to report errors then
+            you may want to set the priority to <see cref="F:System.Net.Mail.MailPriority.High"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.EnableSsl">
+            <summary>
+            Enable or disable use of SSL when sending e-mail message
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.ReplyTo">
+            <summary>
+            Gets or sets the reply-to e-mail address.
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SubjectEncoding">
+            <summary>
+            Gets or sets the subject encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.BodyEncoding">
+            <summary>
+            Gets or sets the body encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender.SmtpAuthentication">
+            <summary>
+            Values for the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property.
+            </summary>
+            <remarks>
+            <para>
+            SMTP authentication modes.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None">
+            <summary>
+            No authentication
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic">
+            <summary>
+            Basic authentication.
+            </summary>
+            <remarks>
+            Requires a username and password to be supplied
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm">
+            <summary>
+            Integrated authentication
+            </summary>
+            <remarks>
+            Uses the Windows credentials from the current thread or process to authenticate.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpPickupDirAppender">
+            <summary>
+            Send an email when a specific logging event occurs, typically on errors 
+            or fatal errors. Rather than sending via smtp it writes a file into the
+            directory specified by <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>. This allows services such
+            as the IIS SMTP agent to manage sending the messages.
+            </summary>
+            <remarks>
+            <para>
+            The configuration for this appender is identical to that of the <c>SMTPAppender</c>,
+            except that instead of specifying the <c>SMTPAppender.SMTPHost</c> you specify
+            <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>.
+            </para>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpPickupDirAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            </remarks>
+            <author>Niall Daley</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+            <remarks>
+            <para>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions">
+            <summary>
+            Activate the options on this appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpPickupDirAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.To">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.PickupDir">
+            <summary>
+            Gets or sets the path to write the messages to.
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the path to write the messages to. This should be the same
+            as that used by the agent sending the messages.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.FileExtension">
+            <summary>
+            Gets or sets the file extension for the generated files
+            </summary>
+            <value>
+            The file extension for the generated files
+            </value>
+            <remarks>
+            <para>
+            The file extension for the generated files
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender">
+            <summary>
+            Appender that allows clients to connect via Telnet to receive log messages
+            </summary>
+            <remarks>	
+            <para>
+            The TelnetAppender accepts socket connections and streams logging messages
+            back to the client.  
+            The output is provided in a telnet-friendly way so that a log can be monitored 
+            over a TCP/IP socket.
+            This allows simple remote monitoring of application logging.
+            </para>
+            <para>
+            The default <see cref="P:log4net.Appender.TelnetAppender.Port"/> is 23 (the telnet port).
+            </para>
+            </remarks>
+            <author>Keith Long</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TelnetAppender.declaringType">
+            <summary>
+            The fully qualified type of the TelnetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.OnClose">
+            <summary>
+            Overrides the parent method to close the socket handler
+            </summary>
+            <remarks>
+            <para>
+            Closes all the outstanding connections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Create the socket handler and wait for connections
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to each connected client.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to each connected client.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.Port">
+            <summary>
+            Gets or sets the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </value>
+            <remarks>
+            <para>
+            The default value is 23 (the telnet port).
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler">
+            <summary>
+            Helper class to manage connected clients
+            </summary>
+            <remarks>
+            <para>
+            The SocketHandler class is used to accept connections from
+            clients.  It is threaded so that clients can connect/disconnect
+            asynchronously.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.#ctor(System.Int32)">
+            <summary>
+            Opens a new server port on <paramref ref="port"/>
+            </summary>
+            <param name="port">the local port to listen on for connections</param>
+            <remarks>
+            <para>
+            Creates a socket handler on the specified local server port.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Send(System.String)">
+            <summary>
+            Sends a string message to each of the connected clients
+            </summary>
+            <param name="message">the text to send</param>
+            <remarks>
+            <para>
+            Sends a string message to each of the connected clients
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.AddClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Add a client to the internal clients list
+            </summary>
+            <param name="client">client to add</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.RemoveClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Remove a client from the internal clients list
+            </summary>
+            <param name="client">client to remove</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.OnConnect(System.IAsyncResult)">
+            <summary>
+            Callback used to accept a connection on the server socket
+            </summary>
+            <param name="asyncResult">The result of the asynchronous operation</param>
+            <remarks>
+            <para>
+            On connection adds to the list of connections 
+            if there are two many open connections you will be disconnected
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Dispose">
+            <summary>
+            Close all network connections
+            </summary>
+            <remarks>
+            <para>
+            Make sure we close all network connections
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.SocketHandler.HasConnections">
+            <summary>
+            Test if this handler has active connections
+            </summary>
+            <value>
+            <c>true</c> if this handler has active connections
+            </value>
+            <remarks>
+            <para>
+            This property will be <c>true</c> while this handler has
+            active connections, that is at least one connection that 
+            the handler will attempt to send a message to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient">
+            <summary>
+            Class that represents a client connected to this handler
+            </summary>
+            <remarks>
+            <para>
+            Class that represents a client connected to this handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.#ctor(System.Net.Sockets.Socket)">
+            <summary>
+            Create this <see cref="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient"/> for the specified <see cref="T:System.Net.Sockets.Socket"/>
+            </summary>
+            <param name="socket">the client's socket</param>
+            <remarks>
+            <para>
+            Opens a stream writer on the socket.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Send(System.String)">
+            <summary>
+            Write a string to the client
+            </summary>
+            <param name="message">string to send</param>
+            <remarks>
+            <para>
+            Write a string to the client
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Dispose">
+            <summary>
+            Cleanup the clients connection
+            </summary>
+            <remarks>
+            <para>
+            Close the socket connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TraceAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Trace"/> class for details on configuring the
+            trace system.
+            </para>
+            <para>
+            Events are written using the <c>System.Diagnostics.Trace.Write(string,string)</c>
+            method. The event's logger name is the default value for the category parameter 
+            of the Write method. 
+            </para>
+            <para>
+            <b>Compact Framework</b><br/>
+            The Compact Framework does not support the <see cref="T:System.Diagnostics.Trace"/>
+            class for any operation except <c>Assert</c>. When using the Compact Framework this
+            appender will write to the <see cref="T:System.Diagnostics.Debug"/> system rather than
+            the Trace system. This appender will therefore behave like the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </para>
+            </remarks>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.AliasDomainAttribute">
+            <summary>
+            Assembly level attribute that specifies a domain to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.DomainAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's domain to its repository by
+            specifying this attribute with the name of the target domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required domains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.AliasRepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies a repository to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.RepositoryAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's repository to its repository by
+            specifying this attribute with the name of the target repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required repositories.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.AliasRepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </summary>
+            <param name="name">The repository to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.AliasRepositoryAttribute.Name">
+            <summary>
+            Gets or sets the repository to alias to this assemby's repository.
+            </summary>
+            <value>
+            The repository to alias to this assemby's repository.
+            </value>
+            <remarks>
+            <para>
+            The name of the repository to alias to this assemby's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.AliasDomainAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasDomainAttribute"/> class with 
+            the specified domain to alias to this assembly's repository.
+            </summary>
+            <param name="name">The domain to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Obsolete. Use <see cref="T:log4net.Config.AliasRepositoryAttribute"/> instead of <see cref="T:log4net.Config.AliasDomainAttribute"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.BasicConfigurator">
+            <summary>
+            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </summary>
+            <remarks>
+            <para>
+            Allows very simple programmatic configuration of log4net.
+            </para>
+            <para>
+            Only one appender can be configured using this configurator.
+            The appender is set at the root of the hierarchy and all logging
+            events will be delivered to that appender.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Config.BasicConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the BasicConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.BasicConfigurator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure">
+            <summary>
+            Initializes the log4net system with a default configuration.
+            </summary>
+            <remarks>
+            <para>
+            Initializes the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the log4net system using the specified appenders.
+            </summary>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initializes the log4net system using the specified appender.
+            </summary>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> with a default configuration.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Initializes the specified repository using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appenders.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.ConfiguratorAttribute">
+            <summary>
+            Base class for all log4net configuration attributes.
+            </summary>
+            <remarks>
+            This is an abstract class that must be extended by 
+            specific configurators. This attribute allows the
+            configurator to be parameterized by an assembly level
+            attribute.
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">
+            <summary>
+            Constructor used by subclasses.
+            </summary>
+            <param name="priority">the ordering priority for this configurator</param>
+            <remarks>
+            <para>
+            The <paramref name="priority"/> is used to order the configurator
+            attributes before they are invoked. Higher priority configurators are executed
+            before lower priority ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Abstract method implemented by a subclass. When this method is called
+            the subclass should configure the <paramref name="targetRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">
+            <summary>
+            Compare this instance to another ConfiguratorAttribute
+            </summary>
+            <param name="obj">the object to compare to</param>
+            <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>
+            <remarks>
+            <para>
+            Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.
+            Sorts by priority in descending order. Objects with the same priority are
+            randomly ordered.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DomainAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging domain for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            <b>DomainAttribute is obsolete. Use RepositoryAttribute instead of DomainAttribute.</b>
+            </para>
+            <para>
+            Assemblies are mapped to logging domains. Each domain has its own
+            logging repository. This attribute specified on the assembly controls
+            the configuration of the domain. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the repository objects to create for the domain. If 
+            this attribute is not specified and a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> is not specified
+            then the assembly will be part of the default shared logging domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.RepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging repository for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            Assemblies are mapped to logging repository. This attribute specified 
+            on the assembly controls
+            the configuration of the repository. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the repository that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the <see cref="T:log4net.Repository.ILoggerRepository"/> object 
+            to create for the assembly. If this attribute is not specified or a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> 
+            is not specified then the assembly will be part of the default shared logging repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class 
+            with the name of the repository.
+            </summary>
+            <param name="name">The name of the repository.</param>
+            <remarks>
+            <para>
+            Initialize the attribute with the name for the assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.Name">
+            <summary>
+            Gets or sets the name of the logging repository.
+            </summary>
+            <value>
+            The string name to use as the name of the repository associated with this
+            assembly.
+            </value>
+            <remarks>
+            <para>
+            This value does not have to be unique. Several assemblies can share the
+            same repository. They will share the logging configuration of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.RepositoryType">
+            <summary>
+            Gets or sets the type of repository to create for this assembly.
+            </summary>
+            <value>
+            The type of repository to create for this assembly.
+            </value>
+            <remarks>
+            <para>
+            The type of the repository to create for the assembly.
+            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            interface.
+            </para>
+            <para>
+            This will be the type of repository created when 
+            the repository is created. If multiple assemblies reference the
+            same repository then the repository is only created once using the
+            <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/> of the first assembly to call into the 
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class 
+            with the name of the domain.
+            </summary>
+            <param name="name">The name of the domain.</param>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DOMConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="T:log4net.Config.DOMConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.XmlConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            <para>
+            If neither of the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>
+            properties are set the configuration is loaded from the application's .config file.
+            If set the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property takes priority over the
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property. The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property
+            specifies a path to a file to load the config from. The path is relative to the
+            application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property is used as a postfix to the assembly file name.
+            The config file must be located in the  application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            For example in a console application setting the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> to
+            <c>config</c> has the same effect as not specifying the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or 
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> properties.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.Watch"/> property can be set to cause the <see cref="T:log4net.Config.XmlConfigurator"/>
+            to watch the configuration file for changes.
+            </para>
+            <note>
+            <para>
+            Log4net will only look for assembly level configuration attributes once.
+            When using the log4net assembly level attributes to control the configuration 
+            of log4net you must ensure that the first call to any of the 
+            <see cref="T:log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration
+            attributes. 
+            </para>
+            <para>
+            If you cannot guarantee the order in which log4net calls will be made from 
+            different assemblies you must use programmatic configuration instead, i.e.
+            call the <see cref="M:XmlConfigurator.Configure()"/> method directly.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Configure the repository using the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            The <paramref name="targetRepository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>
+            class otherwise the <see cref="T:log4net.Config.XmlConfigurator"/> will not be able to
+            configure it.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="targetRepository"/> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.</exception>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from the local file system
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configure the specified repository using a <see cref="T:System.IO.FileInfo"/>
+            </summary>
+            <param name="targetRepository">The repository to configure.</param>
+            <param name="configFile">the FileInfo pointing to the config file</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromUri(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from a URI
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="F:log4net.Config.XmlConfiguratorAttribute.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfiguratorAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile">
+            <summary>
+            Gets or sets the filename of the configuration file.
+            </summary>
+            <value>
+            The filename of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified, this is the name of the configuration file to use with
+            the <see cref="T:log4net.Config.XmlConfigurator"/>. This file path is relative to the
+            <b>application base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>).
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension">
+            <summary>
+            Gets or sets the extension of the configuration file.
+            </summary>
+            <value>
+            The extension of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified this is the extension for the configuration file.
+            The path to the config file is built by using the <b>application 
+            base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>),
+            the <b>assembly file name</b> and the config file extension.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> is set to <c>MyExt</c> then
+            possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or
+            <c>MyClassLibrary.dll.MyExt</c>.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.Watch">
+            <summary>
+            Gets or sets a value indicating whether to watch the configuration file.
+            </summary>
+            <value>
+            <c>true</c> if the configuration should be watched, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            If this flag is specified and set to <c>true</c> then the framework
+            will watch the configuration file and will reload the config each time 
+            the file is modified.
+            </para>
+            <para>
+            The config file can only be watched if it is loaded from local disk.
+            In a No-Touch (Smart Client) deployment where the application is downloaded
+            from a web server the config file may not reside on the local disk
+            and therefore it may not be able to watch it.
+            </para>
+            <note>
+            Watching configuration is not supported on the SSCLI.
+            </note>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
+            <summary>
+            Class to register for the log4net section of the configuration file
+            </summary>
+            <remarks>
+            The log4net section of the configuration file needs to have a section
+            handler registered. This is the section handler used. It simply returns
+            the XML element that is the root of the section.
+            </remarks>
+            <example>
+            Example of registering the log4net section handler :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<configSections>
+            		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
+            	</configSections>
+            	<log4net>
+            		log4net configuration XML goes here
+            	</log4net>
+            </configuration>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
+            <summary>
+            Parses the configuration section.
+            </summary>
+            <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
+            <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>
+            <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>
+            <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.PluginAttribute">
+            <summary>
+            Assembly level attribute that specifies a plugin to attach to 
+            the repository.
+            </summary>
+            <remarks>
+            <para>
+            Specifies the type of a plugin to create and attach to the
+            assembly's repository. The plugin type must implement the
+            <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Plugin.IPluginFactory">
+            <summary>
+            Interface used to create plugins.
+            </summary>
+            <remarks>
+            <para>
+            Interface used to create  a plugin.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPluginFactory.CreatePlugin">
+            <summary>
+            Creates the plugin object.
+            </summary>
+            <returns>the new plugin instance</returns>
+            <remarks>
+            <para>
+            Create and return a new plugin instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="typeName">The type name of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            <para>
+            Where possible use the constructor that takes a <see cref="T:System.Type"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.Type)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="type">The type of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.CreatePlugin">
+            <summary>
+            Creates the plugin object defined by this attribute.
+            </summary>
+            <remarks>
+            <para>
+            Creates the instance of the <see cref="T:log4net.Plugin.IPlugin"/> object as 
+            specified by this attribute.
+            </para>
+            </remarks>
+            <returns>The plugin object.</returns>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.ToString">
+            <summary>
+            Returns a representation of the properties of this object.
+            </summary>
+            <remarks>
+            <para>
+            Overrides base class <see cref="M:Object.ToString()" /> method to 
+            return a representation of the properties of this object.
+            </para>
+            </remarks>
+            <returns>A representation of the properties of this object</returns>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.Type">
+            <summary>
+            Gets or sets the type for the plugin.
+            </summary>
+            <value>
+            The type for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type for the plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.TypeName">
+            <summary>
+            Gets or sets the type name for the plugin.
+            </summary>
+            <value>
+            The type name for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type name for the plugin.
+            </para>
+            <para>
+            Where possible use the <see cref="P:log4net.Config.PluginAttribute.Type"/> property instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.SecurityContextProviderAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">
+            <summary>
+            Construct provider attribute with type specified
+            </summary>
+            <param name="providerType">the type of the provider to use</param>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the SecurityContextProvider
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.
+            Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.SecurityContextProviderAttribute.declaringType">
+            <summary>
+            The fully qualified type of the SecurityContextProviderAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">
+            <summary>
+            Gets or sets the type of the provider to use.
+            </summary>
+            <value>
+            the type of the provider to use.
+            </value>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Uri)">
+            <summary>
+            Configures log4net using the specified configuration URI.
+            </summary>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration data stream.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Uri)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            URI.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.InternalConfigureFromXml(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the specified repository using a <c>log4net</c> element.
+            </summary>
+            <param name="repository">The hierarchy to configure.</param>
+            <param name="element">The element to parse.</param>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            <para>
+            This method is ultimately called by one of the Configure methods 
+            to load the configuration from an <see cref="T:System.Xml.XmlElement"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.m_repositoryName2ConfigAndWatchHandler">
+            <summary>
+            Maps repository names to ConfigAndWatchHandler instances to allow a particular
+            ConfigAndWatchHandler to dispose of its FileSystemWatcher when a repository is 
+            reconfigured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler">
+            <summary>
+            Class used to watch config files.
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="T:System.IO.FileSystemWatcher"/> to monitor
+            changes to a specified file. Because multiple change notifications
+            may be raised when the file is modified, a timer is used to
+            compress the notifications into a single event. The timer
+            waits for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> time before delivering
+            the event notification. If any further <see cref="T:System.IO.FileSystemWatcher"/>
+            change notifications arrive while the timer is waiting it
+            is reset and waits again for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> to
+            elapse.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis">
+            <summary>
+            The default amount of time to wait after receiving notification
+            before reloading the config file.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_configFile">
+            <summary>
+            Holds the FileInfo used to configure the XmlConfigurator
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_repository">
+            <summary>
+            Holds the repository being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_timer">
+            <summary>
+            The timer used to compress the notification events.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_watcher">
+            <summary>
+            Watches file for changes. This object should be disposed when no longer
+            needed to free system handles on the watched resources.
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class to
+            watch a specified config file used to configure a repository.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The configuration file to watch.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.OnWatchedFileChange(System.Object)">
+            <summary>
+            Called by the timer when the configuration has been updated.
+            </summary>
+            <param name="state">null</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.Dispose">
+            <summary>
+            Release the handles held by the watcher and timer.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.CompactRepositorySelector">
+            <summary>
+            The implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface suitable
+            for use with the compact framework
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.IRepositorySelector"/> implementation is a simple
+            mapping between repository name and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            object.
+            </para>
+            <para>
+            The .NET Compact Framework 1.0 does not support retrieving assembly
+            level attributes therefore unlike the <c>DefaultRepositorySelector</c>
+            this selector does not examine the calling assembly for attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Core.IRepositorySelector">
+            <summary>
+            Interface used by the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.Core.IRepositorySelector"/> 
+            to specify the policy for selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> 
+            to return to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association. The results of this method must be repeatable, i.e.
+            when called again with the same arguments the result must be the
+            save value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the named <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repositoryName">The name to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            Lookup a named <see cref="T:log4net.Repository.ILoggerRepository"/>. This is the repository created by
+            calling <see cref="M:CreateRepository(string,Type)"/>.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="assembly">The assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository with the name specified.
+            </summary>
+            <param name="repositoryName">The name to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the name
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same name will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(Assembly, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(Assembly)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>
+            An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances created by 
+            this <see cref="T:log4net.Core.IRepositorySelector"/>.</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Create a new repository selector
+            </summary>
+            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new compact repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
+            </summary>
+            <param name="assembly">not used</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <param name="repositoryName">the name of the repository to lookup</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>. The default 
+            repository is <c>log4net-default-repository</c>. Other repositories 
+            must be created using the <see cref="M:CreateRepository(string, Type)"/>.
+            If the named repository does not exist an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> does not exist</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="assembly">not used</param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            If the <paramref name="repositoryType"/> is <c>null</c> then the
+            default repository type specified to the constructor is used.
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Create a new repository for the repository specified
+            </summary>
+            <param name="repositoryName">the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is null then the default repository type is used.</param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            <para>
+            If the named repository already exists an exception will be thrown.
+            </para>
+            <para>
+            If <paramref name="repositoryType"/> is <c>null</c> then the default 
+            repository type specified to the constructor is used.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> already exists</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.CompactRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the CompactRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notify the registered listeners that the repository has been created
+            </summary>
+            <param name="repository">The repository that has been created</param>
+            <remarks>
+            <para>
+            Raises the <event cref="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">LoggerRepositoryCreatedEvent</event>
+            event.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.DefaultRepositorySelector">
+            <summary>
+            The default implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Uses attributes defined on the calling assembly to determine how to
+            configure the hierarchy for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Creates a new repository selector.
+            </summary>
+            <param name="defaultRepositoryType">The type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null"/>.</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="repositoryAssembly">The assembly use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <remarks>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and the repository 
+            to create can be overridden by specifying the <see cref="T:log4net.Config.RepositoryAttribute"/> 
+            attribute on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> 
+            implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically configured using 
+            any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
+            the <paramref name="repositoryAssembly"/>.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.</returns>
+            <remarks>
+            <para>
+            Returns the named repository. If <paramref name="repositoryName"/> is <c>null</c>
+            a <see cref="T:System.ArgumentNullException"/> is thrown. If the repository 
+            does not exist a <see cref="T:log4net.Core.LogException"/> is thrown.
+            </para>
+            <para>
+            Use <see cref="M:CreateRepository(string, Type)"/> to create a repository.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> does not exist.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type,System.String,System.Boolean)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryName">The name to assign to the created repository</param>
+            <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is <see langword="null"/> then the default repository type is used.</param>
+            <returns>The new repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.AliasRepository(System.String,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Aliases a repository to an existing repository.
+            </summary>
+            <param name="repositoryAlias">The repository to alias.</param>
+            <param name="repositoryTarget">The repository that the repository is aliased to.</param>
+            <remarks>
+            <para>
+            The repository specified will be aliased to the repository when created. 
+            The repository must not already exist.
+            </para>
+            <para>
+            When the repository is created it must utilize the same repository type as 
+            the repository it is aliased to, otherwise the aliasing will fail.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="repositoryAlias"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repositoryTarget"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notifies the registered listeners that the repository has been created.
+            </summary>
+            <param name="repository">The repository that has been created.</param>
+            <remarks>
+            <para>
+            Raises the <see cref="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">
+            <summary>
+            Gets the repository name and repository type for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly that has a <see cref="T:log4net.Config.RepositoryAttribute"/>.</param>
+            <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>
+            <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>
+            <exception cref="T:System.ArgumentNullException"><paramref name="assembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the repository using information from the assembly.
+            </summary>
+            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>
+            attributes which define the configuration for the repository.</param>
+            <param name="repository">The repository to configure.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadPlugins(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined plugins on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to add the plugins to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadAliases(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined aliases on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to alias to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="F:log4net.Core.DefaultRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the DefaultRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ErrorCode">
+            <summary>
+            Defined error codes that can be passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Values passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.GenericFailure">
+            <summary>
+            A general error
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.WriteFailure">
+            <summary>
+            Error while writing output
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FlushFailure">
+            <summary>
+            Failed to flush file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.CloseFailure">
+            <summary>
+            Failed to close file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FileOpenFailure">
+            <summary>
+            Unable to open output file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.MissingLayout">
+            <summary>
+            No layout specified
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.AddressParseFailure">
+            <summary>
+            Failed to parse address
+            </summary>
+        </member>
+        <member name="T:log4net.Core.ExceptionEvaluator">
+            <summary>
+            An evaluator that triggers on an Exception type
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the type of the Exception
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to a Type in <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.    /// 
+            </para>
+            </remarks>
+            <author>Drew Schaeffer</author>
+        </member>
+        <member name="T:log4net.Core.ITriggeringEventEvaluator">
+            <summary>
+            Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action
+            </summary>
+            <remarks>
+            <para>
+            Implementations of this interface allow certain appenders to decide
+            when to perform an appender specific action.
+            </para>
+            <para>
+            The action or behavior triggered is defined by the implementation.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if this event triggers the action
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
+            <remarks>
+            <para>
+            Return <c>true</c> if this event triggers the action
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_type">
+            <summary>
+            The type that causes the trigger to fire.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_triggerOnSubclass">
+            <summary>
+            Causes subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/> to cause the trigger to fire.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor">
+            <summary>
+            Default ctor to allow dynamic creation through a configurator.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor(System.Type,System.Boolean)">
+            <summary>
+            Constructs an evaluator and initializes to trigger on <paramref name="exType"/>
+            </summary>
+            <param name="exType">the type that triggers this evaluator.</param>
+            <param name="triggerOnSubClass">If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.</param>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the logging event Exception 
+            Type is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the Exception Type of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.ExceptionType">
+            <summary>
+            The type that triggers this evaluator.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.TriggerOnSubclass">
+            <summary>
+            If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.IErrorHandler">
+            <summary>
+            Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.
+            </summary>
+            <remarks>
+            <para>
+            Error handling is a particularly tedious to get right because by
+            definition errors are hard to predict and to reproduce. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <param name="errorCode">The error code associated with the error.</param>
+            <remarks>
+            <para>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IFixingRequired">
+            <summary>
+            Interface for objects that require fixing.
+            </summary>
+            <remarks>
+            <para>
+            Interface that indicates that the object requires fixing before it
+            can be taken outside the context of the appender's 
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            When objects that implement this interface are stored 
+            in the context properties maps <see cref="T:log4net.GlobalContext"/>
+            <see cref="P:log4net.GlobalContext.Properties"/> and <see cref="T:log4net.ThreadContext"/>
+            <see cref="P:log4net.ThreadContext.Properties"/> are fixed 
+            (see <see cref="P:log4net.Core.LoggingEvent.Fix"/>) the <see cref="M:log4net.Core.IFixingRequired.GetFixedObject"/>
+            method will be called.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IFixingRequired.GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a portable instance object that represents the current
+            state of this object. The portable object can be stored
+            and logged from any thread with identical results.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILogger">
+            <summary>
+            Interface that all loggers implement
+            </summary>
+            <remarks>
+            <para>
+            This interface supports logging events and testing if a level
+            is enabled for logging.
+            </para>
+            <para>
+            These methods will not throw exceptions. Note to implementor, ensure
+            that the implementation of these methods cannot allow an exception
+            to be thrown to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">the exception to log, including its stack trace. Pass <c>null</c> to not log an exception.</param>
+            <remarks>
+            <para>
+            Generates a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="T:log4net.Core.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Name">
+            <summary>
+            Gets the name of the logger.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILoggerWrapper">
+            <summary>
+            Base interface for all wrappers
+            </summary>
+            <remarks>
+            <para>
+            Base interface for all wrappers.
+            </para>
+            <para>
+            All wrappers must implement this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Core.ILoggerWrapper.Logger">
+            <summary>
+            Get the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this
+            object. The <c>Logger</c> object may not 
+            be the same object as this object because of logger decorators.
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventHandler">
+            <summary>
+            Delegate used to handle logger repository creation event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Core.IRepositorySelector"/> which created the repository.</param>
+            <param name="e">The <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> event args
+            that holds the <see cref="T:log4net.Repository.ILoggerRepository"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> 
+            event is raised every time a <see cref="T:log4net.Repository.ILoggerRepository"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerRepositoryCreationEventArgs.m_repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggerRepositoryCreationEventArgs.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </summary>
+            <param name="repository">the <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created</param>
+            <remarks>
+            <para>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggerRepositoryCreationEventArgs.LoggerRepository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.Level">
+            <summary>
+            Defines the default set of levels recognized by the system.
+            </summary>
+            <remarks>
+            <para>
+            Each <see cref="T:log4net.Core.LoggingEvent"/> has an associated <see cref="T:log4net.Core.Level"/>.
+            </para>
+            <para>
+            Levels have a numeric <see cref="P:log4net.Core.Level.Value"/> that defines the relative 
+            ordering between levels. Two Levels with the same <see cref="P:log4net.Core.Level.Value"/> 
+            are deemed to be equivalent.
+            </para>
+            <para>
+            The levels that are recognized by log4net are set for each <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and each repository can have different levels defined. The levels are stored
+            in the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> on the repository. Levels are
+            looked up by name from the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>.
+            </para>
+            <para>
+            When logging at level INFO the actual level used is not <see cref="F:log4net.Core.Level.Info"/> but
+            the value of <c>LoggerRepository.LevelMap["INFO"]</c>. The default value for this is
+            <see cref="F:log4net.Core.Level.Info"/>, but this can be changed by reconfiguring the level map.
+            </para>
+            <para>
+            Each level has a <see cref="P:log4net.Core.Level.DisplayName"/> in addition to its <see cref="P:log4net.Core.Level.Name"/>. The 
+            <see cref="P:log4net.Core.Level.DisplayName"/> is the string that is written into the output log. By default
+            the display name is the same as the level name, but this can be used to alias levels
+            or to localize the log output.
+            </para>
+            <para>
+            Some of the predefined levels recognized by the system are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Off"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Fatal"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Error"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Warn"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Info"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Debug"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.All"/>.</description>
+            	</item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <param name="displayName">The display name for this level. This may be localized or otherwise different from the name</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.ToString">
+            <summary>
+            Returns the <see cref="T:System.String"/> representation of the current 
+            <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <returns>
+            A <see cref="T:System.String"/> representation of the current <see cref="T:log4net.Core.Level"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns the level <see cref="P:log4net.Core.Level.Name"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Equals(System.Object)">
+            <summary>
+            Compares levels.
+            </summary>
+            <param name="o">The object to compare against.</param>
+            <returns><c>true</c> if the objects are equal.</returns>
+            <remarks>
+            <para>
+            Compares the levels of <see cref="T:log4net.Core.Level"/> instances, and 
+            defers to base class if the target object is not a <see cref="T:log4net.Core.Level"/>
+            instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.GetHashCode">
+            <summary>
+            Returns a hash code
+            </summary>
+            <returns>A hash code for the current <see cref="T:log4net.Core.Level"/>.</returns>
+            <remarks>
+            <para>
+            Returns a hash code suitable for use in hashing algorithms and data 
+            structures like a hash table.
+            </para>
+            <para>
+            Returns the hash code of the level <see cref="P:log4net.Core.Level.Value"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.CompareTo(System.Object)">
+            <summary>
+            Compares this instance to a specified object and returns an 
+            indication of their relative values.
+            </summary>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> instance or <see langword="null"/> to compare with this instance.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description>This instance is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description>This instance is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description>
+            			<para>This instance is greater than <paramref name="r"/>.</para>
+            			<para>-or-</para>
+            			<para><paramref name="r"/> is <see langword="null"/>.</para>
+            			</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            <paramref name="r"/> must be an instance of <see cref="T:log4net.Core.Level"/> 
+            or <see langword="null"/>; otherwise, an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException"><paramref name="r"/> is not a <see cref="T:log4net.Core.Level"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Equality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have the same value.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is the same as the 
+            value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Inequality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have different values.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is different from
+            the value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Compare(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Compares two specified <see cref="T:log4net.Core.Level"/> instances.
+            </summary>
+            <param name="l">The first <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <param name="r">The second <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            two values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description><paramref name="l"/> is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description><paramref name="l"/> is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description><paramref name="l"/> is greater than <paramref name="r"/>.</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.Level.Off">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Off"/> level designates a higher level than all the rest.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Log4Net_Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Emergency">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fatal">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fatal"/> level designates very severe error events 
+            that will presumably lead the application to abort.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Alert">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Alert"/> level designates very severe error events. 
+            Take immediate action, alerts.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Critical">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Critical"/> level designates very severe error events. 
+            Critical condition, critical.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Severe">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Severe"/> level designates very severe error events.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Error">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Error"/> level designates error events that might 
+            still allow the application to continue running.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Warn">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Warn"/> level designates potentially harmful 
+            situations.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Notice">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Notice"/> level designates informational messages 
+            that highlight the progress of the application at the highest level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Info">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Info"/> level designates informational messages that 
+            highlight the progress of the application at coarse-grained level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Debug"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fine">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fine"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Trace">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Trace"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finer">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finer"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Verbose">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Verbose"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finest">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finest"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.All">
+            <summary>
+            The <see cref="F:log4net.Core.Level.All"/> level designates the lowest level possible.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.Level.Name">
+            <summary>
+            Gets the name of this level.
+            </summary>
+            <value>
+            The name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.Value">
+            <summary>
+            Gets the value of this level.
+            </summary>
+            <value>
+            The value of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the value of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.DisplayName">
+            <summary>
+            Gets the display name of this level.
+            </summary>
+            <value>
+            The display name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the display name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Core.Level"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ReadOnly(log4net.Core.LevelCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>LevelCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>LevelCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>LevelCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <c>LevelCollection</c>.
+            </summary>
+            <param name="c">The <c>LevelCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.Level[])">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Core.Level"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[])">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[],System.Int32)">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Add(log4net.Core.Level)">
+            <summary>
+            Adds a <see cref="T:log4net.Core.Level"/> to the end of the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to be added to the end of the <c>LevelCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clear">
+            <summary>
+            Removes all elements from the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Core.LevelCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Contains(log4net.Core.Level)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Core.Level"/> is in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.IndexOf(log4net.Core.Level)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Core.Level"/>
+            in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to locate in the <c>LevelCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>LevelCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Insert(System.Int32,log4net.Core.Level)">
+            <summary>
+            Inserts an element into the <c>LevelCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Remove(log4net.Core.Level)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Core.Level"/> from the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to remove from the <c>LevelCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Core.Level"/> was not found in the <c>LevelCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>LevelCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>LevelCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Core.LevelCollection.Enumerator"/> for the entire <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.LevelCollection)">
+            <summary>
+            Adds the elements of another <c>LevelCollection</c> to the current <c>LevelCollection</c>.
+            </summary>
+            <param name="x">The <c>LevelCollection</c> whose elements should be added to the end of the current <c>LevelCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.Level[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> array to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> collection to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.Level"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>LevelCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.ILevelCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LevelCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelEvaluator">
+            <summary>
+            An evaluator that triggers at a threshold level
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelEvaluator.m_threshold">
+            <summary>
+            The threshold for triggering
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor(log4net.Core.Level)">
+            <summary>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </summary>
+            <param name="threshold">the threshold to trigger at</param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the event level
+            is equal or higher than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelEvaluator.Threshold">
+            <summary>
+            the threshold to trigger at
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.Level"/> that will cause this evaluator to trigger
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelMap">
+            <summary>
+            Mapping between string name and Level object
+            </summary>
+            <remarks>
+            <para>
+            Mapping between string name and <see cref="T:log4net.Core.Level"/> object.
+            This mapping is held separately for each <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The level name is case insensitive.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelMap.m_mapName2Level">
+            <summary>
+            Mapping from level name to Level object. The
+            level name is case insensitive
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelMap.#ctor">
+            <summary>
+            Construct the level map
+            </summary>
+            <remarks>
+            <para>
+            Construct the level map.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Clear">
+            <summary>
+            Clear the internal maps of all levels
+            </summary>
+            <remarks>
+            <para>
+            Clear the internal maps of all levels
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+            <seealso cref="M:Add(string,int,string)"/>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32,System.String)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <param name="displayName">the display name to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(log4net.Core.Level)">
+            <summary>
+            Add a Level to the map
+            </summary>
+            <param name="level">the Level to add</param>
+            <remarks>
+            <para>
+            Add a Level to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.LookupWithDefault(log4net.Core.Level)">
+            <summary>
+            Lookup a named level from the map
+            </summary>
+            <param name="defaultLevel">the name of the level to lookup is taken from this level. 
+            If the level is not set on the map then this level is added</param>
+            <returns>the level in the map with the name specified</returns>
+            <remarks>
+            <para>
+            Lookup a named level from the map. The name of the level to lookup is taken
+            from the <see cref="P:log4net.Core.Level.Name"/> property of the <paramref name="defaultLevel"/>
+            argument.
+            </para>
+            <para>
+            If no level with the specified name is found then the 
+            <paramref name="defaultLevel"/> argument is added to the level map
+            and returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.Item(System.String)">
+            <summary>
+            Lookup a <see cref="T:log4net.Core.Level"/> by name
+            </summary>
+            <param name="name">The name of the Level to lookup</param>
+            <returns>a Level from the map with the name specified</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:log4net.Core.Level"/> from the
+            map with the name specified. If the no level is
+            found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.AllLevels">
+            <summary>
+            Return all possible levels as a list of Level objects.
+            </summary>
+            <returns>all possible levels as a list of Level objects</returns>
+            <remarks>
+            <para>
+            Return all possible levels as a list of Level objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LocationInfo">
+            <summary>
+            The internal representation of caller location information.
+            </summary>
+            <remarks>
+            <para>
+            This class uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.Type)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class based on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="className">The fully qualified class name.</param>
+            <param name="methodName">The method name.</param>
+            <param name="fileName">The file name.</param>
+            <param name="lineNumber">The line number of the method within the file.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class with the specified data.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.declaringType">
+            <summary>
+            The fully qualified type of the LocationInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.MethodName">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.StackFrames">
+            <summary>
+            Gets the stack frames from the stack trace of the caller making the log request
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LoggerManager">
+            <summary>
+            Static manager that controls the creation of repositories
+            </summary>
+            <remarks>
+            <para>
+            Static manager that controls the creation of repositories
+            </para>
+            <para>
+            This class is used by the wrapper managers (e.g. <see cref="T:log4net.LogManager"/>)
+            to provide access to the <see cref="T:log4net.Core.ILogger"/> objects.
+            </para>
+            <para>
+            This manager also holds the <see cref="T:log4net.Core.IRepositorySelector"/> that is used to
+            lookup and create repositories. The selector can be set either programmatically using
+            the <see cref="P:log4net.Core.LoggerManager.RepositorySelector"/> property, or by setting the <c>log4net.RepositorySelector</c>
+            AppSetting in the applications config file to the fully qualified type name of the
+            selector to use. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#ctor">
+            <summary>
+            Private constructor to prevent instances. Only static methods should be used.
+            </summary>
+            <remarks>
+            <para>
+            Private constructor to prevent instances. Only static methods should be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#cctor">
+            <summary>
+            Hook the shutdown event
+            </summary>
+            <remarks>
+            <para>
+            On the full .NET runtime, the static constructor hooks up the 
+            <c>AppDomain.ProcessExit</c> and <c>AppDomain.DomainUnload</c>> events. 
+            These are used to shutdown the log4net system as the application exits.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.RegisterAppDomainEvents">
+            <summary>
+            Register for ProcessExit and DomainUnload events on the AppDomain
+            </summary>
+            <remarks>
+            <para>
+            This needs to be in a separate method because the events make
+            a LinkDemand for the ControlAppDomain SecurityPermission. Because
+            this is a LinkDemand it is demanded at JIT time. Therefore we cannot
+            catch the exception in the method itself, we have to catch it in the
+            caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified assembly's repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified assembly's repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to lookup the repository</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repository">The repository to shutdown.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repository">The repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+            <remarks>
+            <para>
+            Gets an array of all currently defined repositories.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetVersionInfo">
+            <summary>
+            Internal method to get pertinent version info.
+            </summary>
+            <returns>A string of version info.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnDomainUnload(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnProcessExit(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.declaringType">
+            <summary>
+            The fully qualified type of the LoggerManager class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.s_repositorySelector">
+            <summary>
+            Initialize the default repository selector
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerManager.RepositorySelector">
+            <summary>
+            Gets or sets the repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </summary>
+            <value>
+            The repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </value>
+            <remarks>
+            <para>
+            The repository selector (<see cref="T:log4net.Core.IRepositorySelector"/>) is used by 
+            the <see cref="T:log4net.LogManager"/> to create and select repositories 
+            (<see cref="T:log4net.Repository.ILoggerRepository"/>).
+            </para>
+            <para>
+            The caller to <see cref="T:log4net.LogManager"/> supplies either a string name 
+            or an assembly (if not supplied the assembly is inferred using 
+            <see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            <para>
+            This context is used by the selector to lookup a specific repository.
+            </para>
+            <para>
+            For the full .NET Framework, the default repository is <c>DefaultRepositorySelector</c>;
+            for the .NET Compact Framework <c>CompactRepositorySelector</c> is the default
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerWrapperImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.ILoggerWrapper"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This class should be used as the base for all wrapper implementations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerWrapperImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Constructs a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Constructs a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerWrapperImpl.m_logger">
+            <summary>
+            The logger that this object is wrapping
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerWrapperImpl.Logger">
+            <summary>
+            Gets the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that this object is implementing.
+            </value>
+            <remarks>
+            <para>
+            The <c>Logger</c> object may not be the same object as this object 
+            because of logger decorators.
+            </para>
+            <para>
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEventData">
+            <summary>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LoggerName">
+            <summary>
+            The logger name.
+            </summary>
+            <remarks>
+            <para>
+            The logger name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Level">
+            <summary>
+            Level of logging event.
+            </summary>
+            <remarks>
+            <para>
+            Level of logging event. Level cannot be Serializable
+            because it is a flyweight.  Due to its special serialization it
+            cannot be declared final either.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Message">
+            <summary>
+            The application supplied message.
+            </summary>
+            <remarks>
+            <para>
+            The application supplied message of logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ThreadName">
+            <summary>
+            The name of thread
+            </summary>
+            <remarks>
+            <para>
+            The name of thread in which this logging event was generated
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.TimeStamp">
+            <summary>
+            Gets or sets the local time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            Prefer using the <see cref="P:log4net.Core.LoggingEventData.TimeStampUtc"/> setter, since local time can be ambiguous.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LocationInfo">
+            <summary>
+            Location information for the caller.
+            </summary>
+            <remarks>
+            <para>
+            Location information for the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.UserName">
+            <summary>
+            String representation of the user
+            </summary>
+            <remarks>
+            <para>
+            String representation of the user's windows name,
+            like DOMAIN\username
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Identity">
+            <summary>
+            String representation of the identity.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the current thread's principal identity.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ExceptionString">
+            <summary>
+            The string representation of the exception
+            </summary>
+            <remarks>
+            <para>
+            The string representation of the exception
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Domain">
+            <summary>
+            String representation of the AppDomain.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Properties">
+            <summary>
+            Additional event specific properties
+            </summary>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEventData.TimeStampUtc">
+            <summary>
+            Gets or sets the UTC time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            The TimeStamp is stored in the UTC time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.FixFlags">
+            <summary>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </summary>
+            <remarks>
+            <para>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Mdc">
+            <summary>
+            Fix the MDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Ndc">
+            <summary>
+            Fix the NDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Message">
+            <summary>
+            Fix the rendered message
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.ThreadName">
+            <summary>
+            Fix the thread name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.LocationInfo">
+            <summary>
+            Fix the callers location information
+            </summary>
+            <remarks>
+            CAUTION: Very slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.UserName">
+            <summary>
+            Fix the callers windows user name
+            </summary>
+            <remarks>
+            CAUTION: Slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Domain">
+            <summary>
+            Fix the domain friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Identity">
+            <summary>
+            Fix the callers principal name
+            </summary>
+            <remarks>
+            CAUTION: May be slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Exception">
+            <summary>
+            Fix the exception text
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Properties">
+            <summary>
+            Fix the event properties. Active properties must implement <see cref="T:log4net.Core.IFixingRequired"/> in order to be eligible for fixing.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.None">
+            <summary>
+            No fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.All">
+            <summary>
+            All fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Partial">
+            <summary>
+            Partial fields fixed
+            </summary>
+            <remarks>
+            <para>
+            This set of partial fields gives good performance. The following fields are fixed:
+            </para>
+            <list type="bullet">
+            <item><description><see cref="F:log4net.Core.FixFlags.Message"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.ThreadName"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Exception"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Domain"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Properties"/></description></item>
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEvent">
+            <summary>
+            The internal representation of logging events. 
+            </summary>
+            <remarks>
+            <para>
+            When an affirmative decision is made to log then a 
+            <see cref="T:log4net.Core.LoggingEvent"/> instance is created. This instance 
+            is passed around to the different log4net components.
+            </para>
+            <para>
+            This class is of concern to those wishing to extend log4net.
+            </para>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.HostNameProperty">
+            <summary>
+            The key into the Properties map for the host name value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.IdentityProperty">
+            <summary>
+            The key into the Properties map for the thread identity value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.UserNameProperty">
+            <summary>
+            The key into the Properties map for the user name value.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,System.String,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class
+            from the supplied parameters.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="loggerName">The name of the logger of this event.</param>
+            <param name="level">The level of this event.</param>
+            <param name="message">The message of this event.</param>
+            <param name="exception">The exception for this event.</param>
+            <remarks>
+            <para>
+            Except <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.Core.LoggingEvent.Level"/> and <see cref="P:log4net.Core.LoggingEvent.LoggerName"/>, 
+            all fields of <c>LoggingEvent</c> are filled when actually needed. Call
+            <see cref="M:FixVolatileData()"/> to cache all data locally
+            to prevent inconsistencies.
+            </para>
+            <para>This method is called by the log4net framework
+            to create a logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData,log4net.Core.FixFlags)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            The <paramref name="fixedData"/> parameter should be used to specify which fields in the
+            <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>
+            will be captured from the environment if requested or fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.EnsureRepository(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Ensure that the repository is set.
+            </summary>
+            <param name="repository">the value for the repository</param>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)">
+            <summary>
+            Write the rendered message to a TextWriter
+            </summary>
+            <param name="writer">the writer to write the message to</param>
+            <remarks>
+            <para>
+            Unlike the <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property this method
+            does store the message data in the internal cache. Therefore 
+            if called only once this method should be faster than the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property, however if the message is
+            to be accessed multiple times then the property will be more efficient.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            The data in this event must be fixed before it can be serialized.
+            </para>
+            <para>
+            The <see cref="M:FixVolatileData()"/> method must be called during the
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method call if this event 
+            is to be used outside that method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            <para>
+            Does a <see cref="F:log4net.Core.FixFlags.Partial"/> fix of the data
+            in the logging event before returning the event data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData(log4net.Core.FixFlags)">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionStrRep">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            <b>Obsolete. Use <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> instead.</b>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionString">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData">
+            <summary>
+            Fix instance fields that hold volatile data.
+            </summary>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            Calling <see cref="M:FixVolatileData()"/> is equivalent to
+            calling <see cref="M:FixVolatileData(bool)"/> passing the parameter
+            <c>false</c>.
+            </para>
+            <para>
+            See <see cref="M:FixVolatileData(bool)"/> for more
+            information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)">
+            <summary>
+            Fixes instance fields that hold volatile data.
+            </summary>
+            <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            The <paramref name="fastButLoose"/> param controls the data that
+            is fixed. Some of the data that can be fixed takes a long time to 
+            generate, therefore if you do not require those settings to be fixed
+            they can be ignored by setting the <paramref name="fastButLoose"/> param
+            to <c>true</c>. This setting will ignore the <see cref="P:log4net.Core.LoggingEvent.LocationInformation"/>
+            and <see cref="P:log4net.Core.LoggingEvent.UserName"/> settings.
+            </para>
+            <para>
+            Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all 
+            settings are fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)">
+            <summary>
+            Fix the fields specified by the <see cref="T:log4net.Core.FixFlags"/> parameter
+            </summary>
+            <param name="flags">the fields to fix</param>
+            <remarks>
+            <para>
+            Only fields specified in the <paramref name="flags"/> will be fixed.
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.LookupProperty(System.String)">
+            <summary>
+            Lookup a composite property in this event
+            </summary>
+            <param name="key">the key for the property to lookup</param>
+            <returns>the value for the property</returns>
+            <remarks>
+            <para>
+            This event has composite properties that combine together properties from
+            several different contexts in the following order:
+            <list type="definition">
+            	<item>
+            		<term>this events properties</term>
+            		<description>
+            		This event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            		properties are specific to this event only.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the thread properties</term>
+            		<description>
+            		The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            		thread. These properties are shared by all events logged on this thread.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the global properties</term>
+            		<description>
+            		The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            		properties are shared by all the threads in the AppDomain.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetProperties">
+            <summary>
+            Get all the composite properties in this event
+            </summary>
+            <returns>the <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the properties</returns>
+            <remarks>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/> for details of the composite properties 
+            stored by the event.
+            </para>
+            <para>
+            This method returns a single <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the
+            properties defined for this event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_data">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_compositeProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_eventProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_callerStackBoundaryDeclaringType">
+            <summary>
+            The fully qualified Type of the calling 
+            logger class in the stack frame (i.e. the declaring type of the method).
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_message">
+            <summary>
+            The application supplied message of logging event.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_thrownException">
+            <summary>
+            The exception that was thrown.
+            </summary>
+            <remarks>
+            This is not serialized. The string representation
+            is serialized instead.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_repository">
+            <summary>
+            The repository that generated the logging event
+            </summary>
+            <remarks>
+            This is not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_fixFlags">
+            <summary>
+            The fix state for this event
+            </summary>
+            <remarks>
+            These flags indicate which fields have been fixed.
+            Not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_cacheUpdatable">
+            <summary>
+            Indicated that the internal cache is updateable (ie not fixed)
+            </summary>
+            <remarks>
+            This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler
+            changes in the caching strategy.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTime">
+            <summary>
+            Gets the time when the current process started.
+            </summary>
+            <value>
+            This is the time when this process started.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored internally in UTC and converted to the local time zone for this computer.
+            </para>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTimeUtc">
+            <summary>
+            Gets the UTC time when the current process started.
+            </summary>
+            <value>
+            This is the UTC time when this process started.
+            </value>
+            <remarks>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Level">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStamp">
+            <summary>
+            Gets the time of the logging event.
+            </summary>
+            <value>
+            The time of the logging event.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored in UTC and converted to the local time zone for this computer.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStampUtc">
+            <summary>
+            Gets UTC the time of the logging event.
+            </summary>
+            <value>
+            The UTC time of the logging event.
+            </value>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LoggerName">
+            <summary>
+            Gets the name of the logger that logged the event.
+            </summary>
+            <value>
+            The name of the logger that logged the event.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of the logger that logged the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LocationInformation">
+            <summary>
+            Gets the location information for this logging event.
+            </summary>
+            <value>
+            The location information for this logging event.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Core.LocationInfo"/> class for more information on
+            supported frameworks and the different behavior in Debug and
+            Release builds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.MessageObject">
+            <summary>
+            Gets the message object used to initialize this event.
+            </summary>
+            <value>
+            The message object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the message object used to initialize this event.
+            Note that this event may not have a valid message object.
+            If the event is serialized the message object will not 
+            be transferred. To get the text of the message the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined message object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ExceptionObject">
+            <summary>
+            Gets the exception object used to initialize this event.
+            </summary>
+            <value>
+            The exception object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the exception object used to initialize this event.
+            Note that this event may not have a valid exception object.
+            If the event is serialized the exception object will not 
+            be transferred. To get the text of the exception the
+            <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> method must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined exception object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.RenderedMessage">
+            <summary>
+            Gets the message, rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <value>
+            The message rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ThreadName">
+            <summary>
+            Gets the name of the current thread.  
+            </summary>
+            <value>
+            The name of the current thread, or the thread ID when 
+            the name is not available.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.UserName">
+            <summary>
+            Gets the name of the current user.
+            </summary>
+            <value>
+            The name of the current user, or <c>NOT AVAILABLE</c> when the 
+            underlying runtime has no support for retrieving the name of the 
+            current user.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of
+            the current windows user.
+            </para>
+            <para>
+            To improve performance, we could cache the string representation of 
+            the name, and reuse that as long as the identity stayed constant.  
+            Once the identity changed, we would need to re-assign and re-render 
+            the string.
+            </para>
+            <para>
+            However, the <c>WindowsIdentity.GetCurrent()</c> call seems to 
+            return different objects every time, so the current implementation 
+            doesn't do this type of caching.
+            </para>
+            <para>
+            Timing for these operations:
+            </para>
+            <list type="table">
+              <listheader>
+                <term>Method</term>
+                <description>Results</description>
+              </listheader>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent()</c></term>
+                <description>10000 loops, 00:00:00.2031250 seconds</description>
+              </item>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent().Name</c></term>
+                <description>10000 loops, 00:00:08.0468750 seconds</description>
+              </item>
+            </list>
+            <para>
+            This means we could speed things up almost 40 times by caching the 
+            value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since 
+            this takes (8.04-0.20) = 7.84375 seconds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Identity">
+            <summary>
+            Gets the identity of the current thread principal.
+            </summary>
+            <value>
+            The string name of the identity of the current thread principal.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get
+            the name of the current thread principal.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Domain">
+            <summary>
+            Gets the AppDomain friendly name.
+            </summary>
+            <value>
+            The AppDomain friendly name.
+            </value>
+            <remarks>
+            <para>
+            Gets the AppDomain friendly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Properties">
+            <summary>
+            Additional event specific properties.
+            </summary>
+            <value>
+            Additional event specific properties.
+            </value>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            <para>
+            This property is for events that have been added directly to
+            this event. The aggregate properties (which include these
+            event properties) can be retrieved using <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/>
+            and <see cref="M:log4net.Core.LoggingEvent.GetProperties"/>.
+            </para>
+            <para>
+            Once the properties have been fixed <see cref="P:log4net.Core.LoggingEvent.Fix"/> this property
+            returns the combined cached properties. This ensures that updates to
+            this property are always reflected in the underlying storage. When
+            returning the combined properties there may be more keys in the
+            Dictionary than expected.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Fix">
+            <summary>
+            The fixed fields in this event
+            </summary>
+            <value>
+            The set of fields that are fixed in this event
+            </value>
+            <remarks>
+            <para>
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LogImpl">
+            <summary>
+            Implementation of <see cref="T:log4net.ILog"/> wrapper interface.
+            </summary>
+            <remarks>
+            <para>
+            This implementation of the <see cref="T:log4net.ILog"/> interface
+            forwards to the <see cref="T:log4net.Core.ILogger"/> held by the base class.
+            </para>
+            <para>
+            This logger has methods to allow the caller to log at the following
+            levels:
+            </para>
+            <list type="definition">
+              <item>
+                <term>DEBUG</term>
+                <description>
+                The <see cref="M:Debug(object)"/> and <see cref="M:DebugFormat(string, object[])"/> methods log messages
+                at the <c>DEBUG</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Debug"/>. The <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>INFO</term>
+                <description>
+                The <see cref="M:Info(object)"/> and <see cref="M:InfoFormat(string, object[])"/> methods log messages
+                at the <c>INFO</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Info"/>. The <see cref="P:log4net.Core.LogImpl.IsInfoEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>WARN</term>
+                <description>
+                The <see cref="M:Warn(object)"/> and <see cref="M:WarnFormat(string, object[])"/> methods log messages
+                at the <c>WARN</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Warn"/>. The <see cref="P:log4net.Core.LogImpl.IsWarnEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>ERROR</term>
+                <description>
+                The <see cref="M:Error(object)"/> and <see cref="M:ErrorFormat(string, object[])"/> methods log messages
+                at the <c>ERROR</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Error"/>. The <see cref="P:log4net.Core.LogImpl.IsErrorEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>FATAL</term>
+                <description>
+                The <see cref="M:Fatal(object)"/> and <see cref="M:FatalFormat(string, object[])"/> methods log messages
+                at the <c>FATAL</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Fatal"/>. The <see cref="P:log4net.Core.LogImpl.IsFatalEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+            </list>
+            <para>
+            The values for these levels and their semantic meanings can be changed by 
+            configuring the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ILog">
+            <summary>
+            The ILog interface is use by application to log messages into
+            the log4net framework.
+            </summary>
+            <remarks>
+            <para>
+            Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
+            that implement this interface. The <see cref="M:LogManager.GetLogger(Assembly,Type)"/>
+            static method is used to get logger instances.
+            </para>
+            <para>
+            This class contains methods for logging at different levels and also
+            has properties for determining if those logging levels are
+            enabled in the current configuration.
+            </para>
+            <para>
+            This interface can be implemented in different ways. This documentation
+            specifies reasonable behavior that a caller can expect from the actual
+            implementation, however different implementations reserve the right to
+            do things differently.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <seealso cref="T:log4net.LogManager"/>
+            <seealso cref="M:LogManager.GetLogger(Assembly, Type)"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">
+            <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para> For some ILog interface <c>log</c>, when you write:</para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, string construction and concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed (who isn't), then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
+            the <see cref="M:Debug(object)"/>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log. This is the preferred style of logging.
+            </para>
+            <para>Alternatively if your logger is available statically then the is debug
+            enabled state can be stored in a static variable like this:
+            </para>
+            <code lang="C#">
+            private static readonly bool isDebugEnabled = log.IsDebugEnabled;
+            </code>
+            <para>
+            Then when you come to log you can write:
+            </para>
+            <code lang="C#">
+            if (isDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way the debug enabled state is only queried once
+            when the class is loaded. Using a <c>private static readonly</c>
+            variable is the most efficient because it is a run time constant
+            and can be heavily optimized by the JIT compiler.
+            </para>
+            <para>
+            Of course if you use a static readonly variable to
+            hold the enabled state of the logger then you cannot
+            change the enabled state at runtime to vary the logging
+            that is produced. You have to decide if you need absolute
+            speed or runtime flexibility.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="M:DebugFormat(IFormatProvider, string, object[])"/>
+        </member>
+        <member name="P:log4net.ILog.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="M:InfoFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="M:WarnFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="M:ErrorFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="M:FatalFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Construct a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Construct a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ReloadLevels(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Virtual method called when the configuration of the repository changes
+            </summary>
+            <param name="repository">the repository holding the levels</param>
+            <remarks>
+            <para>
+            Virtual method called when the configuration of the repository changes
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <c>DEBUG</c> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>DEBUG</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> passed
+            as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <c>INFO</c> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level.
+            </summary>
+            <param name="message">the message object to log</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <c>WARN</c> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>WARN</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <c>ERROR</c> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>ERROR</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <c>FATAL</c> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>FATAL</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.LoggerRepositoryConfigurationChanged(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for the <see cref="E:log4net.Repository.ILoggerRepository.ConfigurationChanged"/> event
+            </summary>
+            <param name="sender">the repository</param>
+            <param name="e">Empty</param>
+        </member>
+        <member name="F:log4net.Core.LogImpl.ThisDeclaringType">
+            <summary>
+            The fully qualified name of this declaring type not the type of any subclass.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>DEBUG</c>
+            level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>DEBUG</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para>
+            For some <c>log</c> Logger object, when you write:
+            </para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed, then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled())
+            { 
+             log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <c>IsDebugEnabled</c> and once in
+            the <c>Debug</c>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>INFO</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>INFO</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>WARN</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>WARN</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>ERROR</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>ERROR</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>FATAL</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>FATAL</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="T:log4net.Core.MethodItem">
+            <summary>
+            provides method information without actually referencing a System.Reflection.MethodBase
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.MethodItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor">
+            <summary>
+            constructs a method item for an unknown method.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String)">
+            <summary>
+            constructs a method item from the name of the method.
+            </summary>
+            <param name="name"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String,System.String[])">
+            <summary>
+            constructs a method item from the name of the method and its parameters.
+            </summary>
+            <param name="name"></param>
+            <param name="parameters"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.Reflection.MethodBase)">
+            <summary>
+            constructs a method item from a method base by determining the method name and its parameters.
+            </summary>
+            <param name="methodBase"></param>
+        </member>
+        <member name="F:log4net.Core.MethodItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Name">
+            <summary>
+            Gets the method name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The method name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Parameters">
+            <summary>
+            Gets the method parameters of the caller making
+            the logging request.
+            </summary>
+            <value>
+            The method parameters of the caller making
+            the logging request
+            </value>
+            <remarks>
+            <para>
+            Gets the method parameters of the caller making
+            the logging request.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContext">
+            <summary>
+            A SecurityContext used by log4net when interacting with protected resources
+            </summary>
+            <remarks>
+            <para>
+            A SecurityContext used by log4net when interacting with protected resources
+            for example with operating system services. This can be used to impersonate
+            a principal that has been granted privileges on the system resources.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.SecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns>An <see cref="T:System.IDisposable"/> instance that will
+            revoke the impersonation of this SecurityContext, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Impersonate this security context. Further calls on the current
+            thread should now be made in the security context provided
+            by this object. When the <see cref="T:System.IDisposable"/> result 
+            <see cref="M:System.IDisposable.Dispose"/> method is called the security
+            context of the thread should be reverted to the state it was in
+            before <see cref="M:log4net.Core.SecurityContext.Impersonate(System.Object)"/> was called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContextProvider">
+            <summary>
+            The <see cref="T:log4net.Core.SecurityContextProvider"/> providers default <see cref="T:log4net.Core.SecurityContext"/> instances.
+            </summary>
+            <remarks>
+            <para>
+            A configured component that interacts with potentially protected system
+            resources uses a <see cref="T:log4net.Core.SecurityContext"/> to provide the elevated
+            privileges required. If the <see cref="T:log4net.Core.SecurityContext"/> object has
+            been not been explicitly provided to the component then the component
+            will request one from this <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </para>
+            <para>
+            By default the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is
+            an instance of <see cref="T:log4net.Core.SecurityContextProvider"/> which returns only
+            <see cref="T:log4net.Util.NullSecurityContext"/> objects. This is a reasonable default
+            where the privileges required are not know by the system.
+            </para>
+            <para>
+            This default behavior can be overridden by subclassing the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            and overriding the <see cref="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)"/> method to return
+            the desired <see cref="T:log4net.Core.SecurityContext"/> objects. The default provider
+            can be replaced by programmatically setting the value of the 
+            <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> property.
+            </para>
+            <para>
+            An alternative is to use the <c>log4net.Config.SecurityContextProviderAttribute</c>
+            This attribute can be applied to an assembly in the same way as the
+            <c>log4net.Config.XmlConfiguratorAttribute"</c>. The attribute takes
+            the type to use as the <see cref="T:log4net.Core.SecurityContextProvider"/> as an argument.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.SecurityContextProvider.s_defaultProvider">
+            <summary>
+            The default provider
+            </summary>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.#ctor">
+            <summary>
+            Protected default constructor to allow subclassing
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)">
+            <summary>
+            Create a SecurityContext for a consumer
+            </summary>
+            <param name="consumer">The consumer requesting the SecurityContext</param>
+            <returns>An impersonation context</returns>
+            <remarks>
+            <para>
+            The default implementation is to return a <see cref="T:log4net.Util.NullSecurityContext"/>.
+            </para>
+            <para>
+            Subclasses should override this method to provide their own
+            behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.SecurityContextProvider.DefaultProvider">
+            <summary>
+            Gets or sets the default SecurityContextProvider
+            </summary>
+            <value>
+            The default SecurityContextProvider
+            </value>
+            <remarks>
+            <para>
+            The default provider is used by configured components that
+            require a <see cref="T:log4net.Core.SecurityContext"/> and have not had one
+            given to them.
+            </para>
+            <para>
+            By default this is an instance of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that returns <see cref="T:log4net.Util.NullSecurityContext"/> objects.
+            </para>
+            <para>
+            The default provider can be set programmatically by setting
+            the value of this property to a sub class of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that has the desired behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.StackFrameItem">
+            <summary>
+            provides stack frame information without actually referencing a System.Diagnostics.StackFrame
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.StackFrameItem.#ctor(System.Diagnostics.StackFrame)">
+            <summary>
+            returns a stack frame item from a stack frame. This 
+            </summary>
+            <param name="frame"></param>
+            <returns></returns>
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.Method">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.TimeEvaluator">
+            <summary>
+            An evaluator that triggers after specified number of seconds.
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+            <author>Robert Sevcik</author>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL">
+            <summary>
+            The default time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_interval">
+            <summary>
+            The time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_lastTimeUtc">
+            <summary>
+            The UTC time of last check. This gets updated when the object is created and when the evaluator triggers.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor(System.Int32)">
+            <summary>
+            Create a new evaluator using the specified time threshold in seconds.
+            </summary>
+            <param name="interval">
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.TimeEvaluator.Interval">
+            <summary>
+            The time threshold in seconds to trigger after
+            </summary>
+            <value>
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperCreationHandler">
+            <summary>
+            Delegate used to handle creation of new wrappers.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <remarks>
+            <para>
+            Delegate used to handle creation of new wrappers. This delegate
+            is called from the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method to construct the wrapper for the specified logger.
+            </para>
+            <para>
+            The delegate to use is supplied to the <see cref="T:log4net.Core.WrapperMap"/>
+            constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperMap">
+            <summary>
+            Maps between logger objects and wrapper objects.
+            </summary>
+            <remarks>
+            <para>
+            This class maintains a mapping between <see cref="T:log4net.Core.ILogger"/> objects and
+            <see cref="T:log4net.Core.ILoggerWrapper"/> objects. Use the <see cref="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)"/> method to 
+            lookup the <see cref="T:log4net.Core.ILoggerWrapper"/> for the specified <see cref="T:log4net.Core.ILogger"/>.
+            </para>
+            <para>
+            New wrapper instances are created by the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method. The default behavior is for this method to delegate construction
+            of the wrapper to the <see cref="T:log4net.Core.WrapperCreationHandler"/> delegate supplied
+            to the constructor. This allows specialization of the behavior without
+            requiring subclassing of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.#ctor(log4net.Core.WrapperCreationHandler)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/>
+            </summary>
+            <param name="createWrapperHandler">The handler to use to create the wrapper objects.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/> class with 
+            the specified handler to create the wrapper objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)">
+            <summary>
+            Gets the wrapper object for the specified logger.
+            </summary>
+            <returns>The wrapper object for the specified logger</returns>
+            <remarks>
+            <para>
+            If the logger is null then the corresponding wrapper is null.
+            </para>
+            <para>
+            Looks up the wrapper it it has previously been requested and
+            returns it. If the wrapper has never been requested before then
+            the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/> virtual method is
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)">
+            <summary>
+            Creates the wrapper object for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <returns>The wrapper object for the logger.</returns>
+            <remarks>
+            <para>
+            This implementation uses the <see cref="T:log4net.Core.WrapperCreationHandler"/>
+            passed to the constructor to create the wrapper. This method
+            can be overridden in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.RepositoryShutdown(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Called when a monitored repository shutdown event is received.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down</param>
+            <remarks>
+            <para>
+            This method is called when a <see cref="T:log4net.Repository.ILoggerRepository"/> that this
+            <see cref="T:log4net.Core.WrapperMap"/> is holding loggers for has signaled its shutdown
+            event <see cref="E:log4net.Repository.ILoggerRepository.ShutdownEvent"/>. The default
+            behavior of this method is to release the references to the loggers
+            and their wrappers generated for this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.ILoggerRepository_Shutdown(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for repository shutdown event.
+            </summary>
+            <param name="sender">The sender of the event.</param>
+            <param name="e">The event args.</param>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_repositories">
+            <summary>
+            Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_createWrapperHandler">
+            <summary>
+            The handler to use to create the extension wrapper objects.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_shutdownHandler">
+            <summary>
+            Internal reference to the delegate used to register for repository shutdown events.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.WrapperMap.Repositories">
+            <summary>
+            Gets the map of logger repositories.
+            </summary>
+            <value>
+            Map of logger repositories.
+            </value>
+            <remarks>
+            <para>
+            Gets the hashtable that is keyed on <see cref="T:log4net.Repository.ILoggerRepository"/>. The
+            values are hashtables keyed on <see cref="T:log4net.Core.ILogger"/> with the
+            value being the corresponding <see cref="T:log4net.Core.ILoggerWrapper"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.DateFormatter.IDateFormatter">
+            <summary>
+            Render a <see cref="T:System.DateTime"/> as a string.
+            </summary>
+            <remarks>
+            <para>
+            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
+            instance into a string.
+            </para>
+            <para>
+            The <see cref="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/> method is used to render the
+            date to a text writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the specified date as a string.
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:System.DateTime"/> as a string and write it
+            to the <see cref="T:System.IO.TextWriter"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.AbsoluteTimeDateFormat">
+            <summary>
+            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DateAndTimeDateFormat">
+            <summary>
+            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.Iso8601TimeDateFormat">
+            <summary>
+            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Renders the date into a string. Format is <c>"HH:mm:ss"</c>.
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to render the date
+            into a string using a precision up to the second. This method
+            will be called at most once per second and the result will be
+            reused if it is needed again during the same second.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Renders the date into a string. Format is "HH:mm:ss,fff".
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> method to generate the
+            time string up to the seconds and then appends the current
+            milliseconds. The results from <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> are
+            cached and <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> is called at most once
+            per second.
+            </para>
+            <para>
+            Sub classes should override <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/>
+            rather than <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeToTheSecond">
+            <summary>
+            Last stored time with precision up to the second.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeBuf">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeStrings">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"dd MMM yyyy HH:mm:ss,fff"</c>
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format 
+            <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, 
+            <c>"06 Nov 1994 15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Angelika Schnagl</author>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">
+            <summary>
+            Default constructor.
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats a DateTime in the format <c>"dd MMM yyyy HH:mm:ss"</c>
+            for example, <c>"06 Nov 1994 15:49:37"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_dateTimeFormatInfo">
+            <summary>
+            The format info for the invariant culture.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.Iso8601DateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> as <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> specified as a string: <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats the date specified as a string: <c>"yyyy-MM-dd HH:mm:ss"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.SimpleDateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="T:System.DateTime"/> <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="format">The format string.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> class 
+            with the specified format string.
+            </para>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the date using <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </summary>
+            <param name="dateToFormat">The date to convert to a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the date format string supplied to the constructor to call
+            the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method to format the date.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">
+            <summary>
+            The format string used to format the <see cref="T:System.DateTime"/>.
+            </summary>
+            <remarks>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.DenyAllFilter">
+            <summary>
+            This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>. 
+            </summary>
+            <remarks>
+            <para>
+            You can add this filter to the end of a filter chain to
+            switch from the default "accept all unless instructed otherwise"
+            filtering behavior to a "deny all unless instructed otherwise"
+            behavior.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.FilterSkeleton">
+            <summary>
+            Subclass this type to implement customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should extend this class to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.IFilter">
+            <summary>
+            Implement this interface to provide customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should implement this interface to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the logging event should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The LoggingEvent to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.IFilter.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterSkeleton.m_next">
+            <summary>
+            Points to the next filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
+            <summary>
+            Initialize the filter with the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Typically filter's options become active immediately on set, 
+            however this method must still be called. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            <para>
+            This method is marked <c>abstract</c> and must be implemented
+            in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.FilterSkeleton.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            </summary>
+            <param name="loggingEvent">the LoggingEvent to filter</param>
+            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>
+            <remarks>
+            <para>
+            Ignores the event being logged and just returns
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter
+            chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter
+            should only be used as the last filter in the chain
+            as any further filters will be ignored!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.FilterDecision">
+            <summary>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </summary>
+            <remarks>
+            <para>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Deny">
+            <summary>
+            The log event must be dropped immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Neutral">
+            <summary>
+            This filter is neutral with respect to the log event. 
+            The remaining filters, if any, should be consulted for a final decision.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Accept">
+            <summary>
+            The log event must be logged immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="T:log4net.Filter.LevelMatchFilter">
+            <summary>
+            This is a very simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and
+            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value
+            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.Core.Level"/> of the 
+            <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 
+            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set
+            to <c>true</c>, if it is <c>false</c> then 
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">
+            <summary>
+            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.Accept"/> on a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">
+            <summary>
+            the <see cref="T:log4net.Core.Level"/> to match against
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Tests if the <see cref="T:log4net.Core.Level"/> of the logging event matches that of the filter
+            </summary>
+            <param name="loggingEvent">the event to filter</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the event matches the level of the
+            filter then the result of the function depends on the
+            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then
+            the function will return <see cref="F:log4net.Filter.FilterDecision.Accept"/>, it it is false then it
+            will return <see cref="F:log4net.Filter.FilterDecision.Deny"/>. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">
+            <summary>
+            The <see cref="T:log4net.Core.Level"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            The level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LevelRangeFilter">
+            <summary>
+            This is a simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            that determine the range of priorities that are matched, and
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range
+            of priorities and the <see cref="T:log4net.Core.Level"/> of the <see cref="T:log4net.Core.LoggingEvent"/>, then the 
+            <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"/> 
+            option value is set to <c>true</c>, if it is <c>false</c>
+            then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when matching a <see cref="T:log4net.Core.Level"/>
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">
+            <summary>
+            the minimum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">
+            <summary>
+            the maximum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if the event should be logged.
+            </summary>
+            <param name="loggingEvent">the logging event to check</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the logging event is outside the range
+            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            is returned. If the <see cref="T:log4net.Core.Level"/> is matched then the value of
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">
+            <summary>
+            Set the minimum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The minimum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">
+            <summary>
+            Sets the maximum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The maximum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LoggerMatchFilter">
+            <summary>
+            Simple filter to match a string in the event's logger name.
+            </summary>
+            <remarks>
+            <para>
+            The works very similar to the <see cref="T:log4net.Filter.LevelMatchFilter"/>. It admits two 
+            options <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> and <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>. If the 
+            <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <see cref="T:log4net.Core.LoggingEvent"/> starts 
+            with the value of the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> option, then the 
+            <see cref="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in 
+            case the <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> option value is set to <c>true</c>, 
+            if it is <c>false</c> then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_loggerToMatch">
+            <summary>
+            The logger name string to substring match against the event
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>.
+            If the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> equals the beginning of 
+            the incoming <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> (<see cref="M:String.StartsWith(string)"/>)
+            then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch">
+            <summary>
+            The <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            This filter will attempt to match this value against logger name in
+            the following way. The match will be done against the beginning of the
+            logger name (using <see cref="M:String.StartsWith(string)"/>). The match is
+            case sensitive. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.MdcFilter">
+            <summary>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with layered properties the
+            <see cref="T:log4net.Filter.PropertyFilter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.PropertyFilter">
+            <summary>
+            Simple filter to match a string an event property
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the value for a
+            specific event property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Filter.StringMatchFilter">
+            <summary>
+            Simple filter to match a string in the rendered message
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the rendered message
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">
+            <summary>
+            The string to substring match against the message
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">
+            <summary>
+            A string regex to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">
+            <summary>
+            A regex object to match (generated from m_stringRegexToMatch)
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">
+            <summary>
+            Initialize and precompile the Regex if required
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the message then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">
+            <summary>
+            Sets the static string to match
+            </summary>
+            <remarks>
+            <para>
+            The string that will be substring matched against
+            the rendered message. If the message contains this
+            string then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">
+            <summary>
+            Sets the regular expression to match
+            </summary>
+            <remarks>
+            <para>
+            The regular expression pattern that will be matched against
+            the rendered message. If the message matches this
+            pattern then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.PropertyFilter.m_key">
+            <summary>
+            The key to use to lookup the string from the event properties
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The event property for the <see cref="P:log4net.Filter.PropertyFilter.Key"/> is matched against 
+            the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the property value then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.PropertyFilter.Key">
+            <summary>
+            The key to lookup in the event properties and then match against.
+            </summary>
+            <remarks>
+            <para>
+            The key name to use to lookup in the properties map of the
+            <see cref="T:log4net.Core.LoggingEvent"/>. The match will be performed against 
+            the value of this property if it exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.NdcFilter">
+            <summary>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with named stacks stored in the
+            properties collections the <see cref="T:log4net.Filter.PropertyFilter"/> should 
+            be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.NdcFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Sets the <see cref="P:log4net.Filter.PropertyFilter.Key"/> to <c>"NDC"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AppDomainPatternConverter">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Util.PatternConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            <para>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.#ctor">
+            <summary>
+            Protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternConverter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Evaluate this pattern converter and write the output to a writer.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the appropriate way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next pattern converter in the chains
+            </summary>
+            <param name="patternConverter">the pattern converter that should follow this converter in the chain</param>
+            <returns>the next converter</returns>
+            <remarks>
+            <para>
+            The PatternConverter can merge with its neighbor during this method (or a sub class).
+            Therefore the return value may or may not be the value of the argument passed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the pattern converter to the writer with appropriate formatting
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            This method calls <see cref="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)"/> to allow the subclass to perform
+            appropriate conversion of the pattern converter. If formatting options have
+            been specified via the <see cref="P:log4net.Util.PatternConverter.FormattingInfo"/> then this method will
+            apply those formattings before writing the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SpacePad(System.IO.TextWriter,System.Int32)">
+            <summary>
+            Fast space padding method.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> to which the spaces will be appended.</param>
+            <param name="length">The number of spaces to be padded.</param>
+            <remarks>
+            <para>
+            Fast space padding method.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.m_option">
+            <summary>
+            The option string to the converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionary)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionary"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionaryEnumerator)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionaryEnumerator"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteObject(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Object)">
+            <summary>
+            Write an object to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the Object to a writer. If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the object to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Next">
+            <summary>
+            Get the next pattern converter in the chain
+            </summary>
+            <value>
+            the next pattern converter in the chain
+            </value>
+            <remarks>
+            <para>
+            Get the next pattern converter in the chain
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.FormattingInfo">
+            <summary>
+            Gets or sets the formatting info for this converter
+            </summary>
+            <value>
+            The formatting info for this converter
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the formatting info for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Option">
+            <summary>
+            Gets or sets the option value for this converter
+            </summary>
+            <summary>
+            The option for this converter
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the option value for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+        </member>
+        <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">
+            <summary>
+            Flag indicating if this converter handles exceptions
+            </summary>
+            <remarks>
+            <c>false</c> if this converter handles exceptions
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">
+            <summary>
+            Flag indicating if this converter handles the logging event exception
+            </summary>
+            <value><c>false</c> if this converter handles the logging event exception</value>
+            <remarks>
+            <para>
+            If this converter handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the property should be set to <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this converter does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AppDomainPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.DatePatternConverter">
+            <summary>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <remarks>
+            <para>
+            Render the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,yyyy"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Layout.Pattern.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter pattern based on the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ExceptionPatternConverter">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception or the exception property specified
+            by the Option value does not exist then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            <para>
+            Recognized values for the Option parameter are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>Message</description>
+            	</item>
+            	<item>
+            		<description>Source</description>
+            	</item>
+            	<item>
+            		<description>StackTrace</description>
+            	</item>
+            	<item>
+            		<description>TargetSite</description>
+            	</item>
+            	<item>
+            		<description>HelpLink</description>
+            	</item>		
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FileLocationPatternConverter">
+            <summary>
+            Writes the caller location file name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FileLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location file name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FullLocationPatternConverter">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FullLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.IdentityPatternConverter">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.IdentityPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <paramref name="loggingEvent"/> 
+            <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LevelPatternConverter">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LineLocationPatternConverter">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LineLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LoggerPatternConverter">
+            <summary>
+            Converter for logger name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NamedPatternConverter">
+            <summary>
+            Converter to output and truncate <c>'.'</c> separated strings
+            </summary>
+            <remarks>
+            <para>
+            This abstract class supports truncating a <c>'.'</c> separated string
+            to show a specified number of elements from the right hand side.
+            This is used to truncate class names that are fully qualified.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> method to
+            return the fully qualified string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Get the fully qualified string data
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>the fully qualified name</returns>
+            <remarks>
+            <para>
+            Overridden by subclasses to get the fully qualified name before the
+            precision is applied to it.
+            </para>
+            <para>
+            Return the fully qualified <c>'.'</c> (dot/period) separated string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> to the precision
+            specified by the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.NamedPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the NamedPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LoggerPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the logger
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified logger name</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MessagePatternConverter">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MethodLocationPatternConverter">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MethodLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NdcPatternConverter">
+            <summary>
+            Converter to include event NDC
+            </summary>
+            <remarks>
+            <para>
+            Outputs the value of the event property named <c>NDC</c>.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NdcPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event NDC to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            As the thread context stacks are now stored in named event properties
+            this converter simply looks up the value of the <c>NDC</c> property.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PropertyPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">
+            <summary>
+            Converter to output the relative time of the event
+            </summary>
+            <remarks>
+            <para>
+            Converter to output the time of the event relative to the start of the program.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the relative time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the relative time of the event in milliseconds.
+            That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>
+            and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
+            <summary>
+            Helper method to get the time difference between two DateTime objects
+            </summary>
+            <param name="start">start time (in the current local time zone)</param>
+            <param name="end">end time (in the current local time zone)</param>
+            <returns>the time difference in milliseconds</returns>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTraceDetailPatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            </para>
+            </remarks>
+            <author>Adam Davies</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTracePatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            </para>
+            </remarks>
+            <author>Michael Cromwell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the strack frames to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.GetMethodInformation(log4net.Core.MethodItem)">
+            <summary>
+            Returns the Name of the method
+            </summary>
+            <param name="method"></param>
+            <remarks>This method was created, so this class could be used as a base class for StackTraceDetailPatternConverter</remarks>
+            <returns>string</returns>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTracePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTracePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTraceDetailPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTraceDetailPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ThreadPatternConverter">
+            <summary>
+            Converter to include event thread name
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ThreadPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the ThreadName to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.TypeNamePatternConverter">
+            <summary>
+            Pattern converter for the class name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.TypeNamePatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the class
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified type name for the caller location</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UserNamePatternConverter">
+            <summary>
+            Converter to include event user name
+            </summary>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UserNamePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UtcDatePatternConverter">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            Uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> 
+            in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.Pattern.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UtcDatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted
+            to Universal time before it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Layout.Pattern.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.DynamicPatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string that re-evaluates on each call.
+            </summary>
+            <remarks>
+            <para>This class is built on <see cref="T:log4net.Layout.PatternLayout"></see> and provides all the
+            features and capabilities of PatternLayout.  PatternLayout is a 'static' class
+            in that its layout is done once at configuration time.  This class will recreate
+            the layout on each reference.</para>
+            <para>One important difference between PatternLayout and DynamicPatternLayout is the
+            treatment of the Header and Footer parameters in the configuration.  The Header and Footer
+            parameters for DynamicPatternLayout must be syntactically in the form of a PatternString,
+            but should not be marked as type log4net.Util.PatternString.  Doing so causes the
+            pattern to be statically converted at configuration time and causes DynamicPatternLayout
+            to perform the same as PatternLayout.</para>
+            <para>Please see <see cref="T:log4net.Layout.PatternLayout"/> for complete documentation.</para>
+            <example>
+            &lt;layout type="log4net.Layout.DynamicPatternLayout"&gt;
+              &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;
+              &lt;param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;
+            &lt;/layout&gt;
+            </example>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.PatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string.
+            </summary>
+            <remarks>
+            <para>
+            The goal of this class is to <see cref="M:PatternLayout.Format(TextWriter,LoggingEvent)"/> a 
+            <see cref="T:log4net.Core.LoggingEvent"/> as a string. The results
+            depend on the <i>conversion pattern</i>.
+            </para>
+            <para>
+            The conversion pattern is closely related to the conversion
+            pattern of the printf function in C. A conversion pattern is
+            composed of literal text and format control expressions called
+            <i>conversion specifiers</i>.
+            </para>
+            <para>
+            <i>You are free to insert any literal text within the conversion
+            pattern.</i>
+            </para>
+            <para>
+            Each conversion specifier starts with a percent sign (%) and is
+            followed by optional <i>format modifiers</i> and a <i>conversion
+            pattern name</i>. The conversion pattern name specifies the type of
+            data, e.g. logger, level, date, thread name. The format
+            modifiers control such things as field width, padding, left and
+            right justification. The following is a simple example.
+            </para>
+            <para>
+            Let the conversion pattern be <b>"%-5level [%thread]: %message%newline"</b> and assume
+            that the log4net environment was set to use a PatternLayout. Then the
+            statements
+            </para>
+            <code lang="C#">
+            ILog log = LogManager.GetLogger(typeof(TestApp));
+            log.Debug("Message 1");
+            log.Warn("Message 2");   
+            </code>
+            <para>would yield the output</para>
+            <code>
+            DEBUG [main]: Message 1
+            WARN  [main]: Message 2  
+            </code>
+            <para>
+            Note that there is no explicit separator between text and
+            conversion specifiers. The pattern parser knows when it has reached
+            the end of a conversion specifier when it reads a conversion
+            character. In the example above the conversion specifier
+            <b>%-5level</b> means the level of the logging event should be left
+            justified to a width of five characters.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>a</term>
+                    <description>Equivalent to <b>appdomain</b></description>
+                </item>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+            			Used to output the friendly name of the AppDomain where the 
+            			logging event was generated. 
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-cache</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-context</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-request</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-session</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>c</term>
+                    <description>Equivalent to <b>logger</b></description>
+                </item>
+                <item>
+                    <term>C</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>class</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>d</term>
+                    <description>Equivalent to <b>date</b></description>
+                </item>
+                <item>
+            		<term>date</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>exception</term>
+            		<description>
+            			<para>
+            			Used to output the exception passed in with the log message.
+            			</para>
+            			<para>
+            			If an exception object is stored in the logging event
+            			it will be rendered into the pattern output with a
+            			trailing newline.
+            			If there is no exception then nothing will be output
+            			and no trailing newline will be appended.
+            			It is typical to put a newline before the exception
+            			and to have the exception as the last data in the pattern.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>F</term>
+                    <description>Equivalent to <b>file</b></description>
+                </item>
+            	<item>
+            		<term>file</term>
+            		<description>
+            			<para>
+            			Used to output the file name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>identity</term>
+            		<description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>l</term>
+                    <description>Equivalent to <b>location</b></description>
+                </item>
+                <item>
+                    <term>L</term>
+                    <description>Equivalent to <b>line</b></description>
+                </item>
+            	<item>
+            		<term>location</term>
+            		<description>
+            			<para>
+            			Used to output location information of the caller which generated
+            			the logging event.
+            			</para>
+            			<para>
+            			The location information depends on the CLI implementation but
+            			usually consists of the fully qualified name of the calling
+            			method followed by the callers source the file name and line
+            			number between parentheses.
+            			</para>
+            			<para>
+            			The location information can be very useful. However, its
+            			generation is <b>extremely</b> slow. Its use should be avoided
+            			unless execution speed is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>level</term>
+            		<description>
+            			<para>
+            			Used to output the level of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>line</term>
+            		<description>
+            			<para>
+            			Used to output the line number from where the logging request
+            			was issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>logger</term>
+                    <description>
+                        <para>
+            			Used to output the logger of the logging event. The
+            			logger conversion specifier can be optionally followed by
+            			<i>precision specifier</i>, that is a decimal constant in
+            			brackets.
+                        </para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the logger name will be
+            			printed. By default the logger name is printed in full.
+            			</para>
+            			<para>
+            			For example, for the logger name "a.b.c" the pattern
+            			<b>%logger{2}</b> will output "b.c".
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>m</term>
+                    <description>Equivalent to <b>message</b></description>
+                </item>
+                <item>
+                    <term>M</term>
+                    <description>Equivalent to <b>method</b></description>
+                </item>
+            	<item>
+            		<term>message</term>
+            		<description>
+            			<para>
+            			Used to output the application supplied message associated with 
+            			the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>mdc</term>
+            		<description>
+            			<para>
+            			The MDC (old name for the ThreadContext.Properties) is now part of the
+            			combined event properties. This pattern is supported for compatibility
+            			but is equivalent to <b>property</b>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>method</term>
+            		<description>
+            			<para>
+            			Used to output the method name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>n</term>
+                    <description>Equivalent to <b>newline</b></description>
+                </item>
+            	<item>
+            		<term>newline</term>
+            		<description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+            		</description>
+            	</item>
+            	<item>
+            		<term>ndc</term>
+            		<description>
+            			<para>
+            			Used to output the NDC (nested diagnostic context) associated
+            			with the thread that generated the logging event.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>p</term>
+                    <description>Equivalent to <b>level</b></description>
+                </item>
+                <item>
+                    <term>P</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+                <item>
+                    <term>properties</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+            	<item>
+            		<term>property</term>
+            		<description>
+            			<para>
+            			Used to output the an event specific property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are added to events by loggers or appenders. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the event properties</term>
+            					<description>
+            					The event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            					properties are specific to this event only.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+            			
+            		</description>
+            	</item>
+                <item>
+                    <term>r</term>
+                    <description>Equivalent to <b>timestamp</b></description>
+                </item>
+            	<item>
+            		<term>stacktrace</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktrace{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+            			type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>stacktracedetail</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktracedetail{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+                        type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+                <item>
+                    <term>t</term>
+                    <description>Equivalent to <b>thread</b></description>
+                </item>
+            	<item>
+            		<term>timestamp</term>
+            		<description>
+            			<para>
+            			Used to output the number of milliseconds elapsed since the start
+            			of the application until the creation of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>thread</term>
+            		<description>
+            			<para>
+            			Used to output the name of the thread that generated the
+            			logging event. Uses the thread number if no name is available.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>type</term> 
+            		<description>
+            			<para>
+            			Used to output the fully qualified type name of the caller
+            			issuing the logging request. This conversion specifier
+            			can be optionally followed by <i>precision specifier</i>, that
+            			is a decimal constant in brackets.
+            			</para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the class name will be
+            			printed. By default the class name is output in fully qualified form.
+            			</para>
+            			<para>
+            			For example, for the class name "log4net.Layout.PatternLayout", the
+            			pattern <b>%type{1}</b> will output "PatternLayout".
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating the caller class information is
+            			slow. Thus, its use should be avoided unless execution speed is
+            			not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+                </item>
+                <item>
+                    <term>u</term>
+                    <description>Equivalent to <b>identity</b></description>
+                </item>
+            	<item>
+            		<term>username</term>
+            		<description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller WindowsIdentity information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>utcdate</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>w</term>
+                    <description>Equivalent to <b>username</b></description>
+                </item>
+                <item>
+                    <term>x</term>
+                    <description>Equivalent to <b>ndc</b></description>
+                </item>
+                <item>
+                    <term>X</term>
+                    <description>Equivalent to <b>mdc</b></description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            The single letter patterns are deprecated in favor of the 
+            longer more descriptive pattern names.
+            </para>
+            <para>
+            By default the relevant information is output as is. However,
+            with the aid of format modifiers it is possible to change the
+            minimum field width, the maximum field width and justification.
+            </para>
+            <para>
+            The optional format modifier is placed between the percent sign
+            and the conversion pattern name.
+            </para>
+            <para>
+            The first optional format modifier is the <i>left justification
+            flag</i> which is just the minus (-) character. Then comes the
+            optional <i>minimum field width</i> modifier. This is a decimal
+            constant that represents the minimum number of characters to
+            output. If the data item requires fewer characters, it is padded on
+            either the left or the right until the minimum width is
+            reached. The default is to pad on the left (right justify) but you
+            can specify right padding with the left justification flag. The
+            padding character is space. If the data item is larger than the
+            minimum field width, the field is expanded to accommodate the
+            data. The value is never truncated.
+            </para>
+            <para>
+            This behavior can be changed using the <i>maximum field
+            width</i> modifier which is designated by a period followed by a
+            decimal constant. If the data item is longer than the maximum
+            field, then the extra characters are removed from the
+            <i>beginning</i> of the data item and not from the end. For
+            example, it the maximum field width is eight and the data item is
+            ten characters long, then the first two characters of the data item
+            are dropped. This behavior deviates from the printf function in C
+            where truncation is done from the end.
+            </para>
+            <para>
+            Below are various format modifier examples for the logger
+            conversion specifier.
+            </para>
+            <div class="tablediv">
+            	<table class="dtTABLE" cellspacing="0">
+            		<tr>
+            			<th>Format modifier</th>
+            			<th>left justify</th>
+            			<th>minimum width</th>
+            			<th>maximum width</th>
+            			<th>comment</th>
+            		</tr>
+            		<tr>
+            			<td align="center">%20logger</td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is less than 20
+            				characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger 
+            				name is less than 20 characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%.30logger</td>
+            			<td align="center">NA</td>
+            			<td align="center">none</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Truncate from the beginning if the logger 
+            				name is longer than 30 characters.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center"><nobr>%20.30logger</nobr></td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20.30logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            	</table>
+            </div>
+            <para>
+            <b>Note about caller location information.</b><br/>
+            The following patterns <c>%type %file %line %method %location %class %C %F %L %l %M</c> 
+            all generate caller location information.
+            Location information uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            </note>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </note>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Layout.PatternLayout"/>
+            instance using the <see cref="M:AddConverter(string, Type)"/> method.
+            </para>
+            </remarks>
+            <example>
+            This is a more detailed pattern.
+            <code><b>%timestamp [%thread] %level %logger %ndc - %message%newline</b></code>
+            </example>
+            <example>
+            A similar pattern except that the relative time is
+            right padded if less than 6 digits, thread name is right padded if
+            less than 15 characters and truncated if longer and the logger
+            name is left padded if shorter than 30 characters and truncated if
+            longer.
+            <code><b>%-6timestamp [%15.15thread] %-5level %30.30logger %ndc - %message%newline</b></code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="T:log4net.Layout.LayoutSkeleton">
+            <summary>
+            Extend this abstract class to create your own log layout format.
+            </summary>
+            <remarks>
+            <para>
+            This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
+            interface. Most layout objects should extend this class.
+            </para>
+            </remarks>
+            <remarks>
+            <note type="inheritinfo">
+            <para>
+            Subclasses must implement the <see cref="M:Format(TextWriter,LoggingEvent)"/>
+            method.
+            </para>
+            <para>
+            Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default
+            constructor.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.ILayout">
+            <summary>
+            Interface implemented by layout objects
+            </summary>
+            <remarks>
+            <para>
+            An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            as text. The <see cref="M:Format(TextWriter,LoggingEvent)"/> method is called by an
+            appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.
+            </para>
+            <para>
+            The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            text that is appender before any events and after all the events respectively.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text and output to a writer.
+            </para>
+            <para>
+            If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the
+            event to be formatted as a <see cref="T:System.String"/> then the following
+            code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.
+            </para>
+            <code lang="C#">
+            StringWriter writer = new StringWriter();
+            Layout.Format(writer, loggingEvent);
+            string formattedEvent = writer.ToString();
+            </code>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type</value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This is a MIME type e.g. <c>"text/plain"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.IgnoresException">
+            <summary>
+            Flag indicating if this layout handle exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_header">
+            <summary>
+            The header text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
+            <summary>
+            The footer text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <remarks>
+            <para>
+            <c>false</c> if this layout handles exceptions
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
+            <summary>
+            Empty default constructor
+            </summary>
+            <remarks>
+            <para>
+            Empty default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This method must be implemented by the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Convenience method for easily formatting the logging event into a string variable.
+            </summary>
+            <param name="loggingEvent"></param>
+            <remarks>
+            Creates a new StringWriter instance to store the formatted logging event.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type is <c>"text/plain"</c></value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This base class uses the value <c>"text/plain"</c>.
+            To change this value a subclass must override this
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this layout does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DefaultConversionPattern">
+            <summary>
+            Default pattern string for log output. 
+            </summary>
+            <remarks>
+            <para>
+            Default pattern string for log output. 
+            Currently set to the string <b>"%message%newline"</b> 
+            which just prints the application supplied message. 
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DetailConversionPattern">
+            <summary>
+            A detailed conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            A conversion pattern which includes Time, Thread, Logger, and Nested Context.
+            Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+            <remarks>
+            <para>
+            This static map is overridden by the m_converterRegistry instance map
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternLayout only
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+            <remarks>
+            <para>
+            Defines the builtin global rules.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor">
+            <summary>
+            Constructs a PatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            As per the <see cref="T:log4net.Core.IOptionHandler"/> contract the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>
+            method must be called after the properties on this object have been
+            configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a PatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            When using this constructor the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method 
+            need not be called. This may not be the case when using a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">
+            <summary>
+            Create the pattern parser instance
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/> that will format the event</returns>
+            <remarks>
+            <para>
+            Creates the <see cref="T:log4net.Util.PatternParser"/> used to parse the conversion string. Sets the
+            global and instance rules on the <see cref="T:log4net.Util.PatternParser"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Parse the <see cref="T:log4net.Core.LoggingEvent"/> using the patter format
+            specified in the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a named pattern converter to this instance. This
+            converter will be used in the formatting of the event.
+            This method must be called before <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>.
+            </para>
+            <para>
+            The <paramref name="type"/> specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">
+            <summary>
+            The pattern formatting string
+            </summary>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_headerPatternString">
+            <summary>
+            The header PatternString
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_footerPatternString">
+            <summary>
+            The footer PatternString
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor">
+            <summary>
+            Constructs a DynamicPatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a DynamicPatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.ExceptionLayout">
+            <summary>
+            A Layout that renders only the Exception text from the logging event
+            </summary>
+            <remarks>
+            <para>
+            A Layout that renders only the Exception text from the logging event.
+            </para>
+            <para>
+            This Layout should only be used with appenders that utilize multiple
+            layouts (e.g. <see cref="T:log4net.Appender.AdoNetAppender"/>).
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Constructs a ExceptionLayout
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            Part of the <see cref="T:log4net.Core.IOptionHandler"/> component activation
+            framework.
+            </para>
+            <para>
+            This method does nothing as options become effective immediately.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the exception text from the logging event
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Write the exception string to the <see cref="T:System.IO.TextWriter"/>.
+            The exception string is retrieved from <see cref="M:LoggingEvent.GetExceptionString()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.IRawLayout">
+            <summary>
+            Interface for raw layout objects
+            </summary>
+            <remarks>
+            <para>
+            Interface used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            to an object.
+            </para>
+            <para>
+            This interface should not be confused with the
+            <see cref="T:log4net.Layout.ILayout"/> interface. This interface is used in
+            only certain specialized situations where a raw object is
+            required rather than a formatted string. The <see cref="T:log4net.Layout.ILayout"/>
+            is not generally useful than this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.IRawLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Implement this method to create your own layout format.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Layout2RawLayoutAdapter">
+            <summary>
+            Adapts any <see cref="T:log4net.Layout.ILayout"/> to a <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <remarks>
+            <para>
+            Where an <see cref="T:log4net.Layout.IRawLayout"/> is required this adapter
+            allows a <see cref="T:log4net.Layout.ILayout"/> to be specified.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Layout.Layout2RawLayoutAdapter.m_layout">
+            <summary>
+            The layout to adapt
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Construct a new adapter
+            </summary>
+            <param name="layout">the layout to adapt</param>
+            <remarks>
+            <para>
+            Create the adapter for the specified <paramref name="layout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Format the logging event as an object.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Format the logging event as an object.
+            </para>
+            <para>
+            Uses the <see cref="T:log4net.Layout.ILayout"/> object supplied to 
+            the constructor to perform the formatting.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawLayoutConverter">
+            <summary>
+            Type converter for the <see cref="T:log4net.Layout.IRawLayout"/> interface
+            </summary>
+            <remarks>
+            <para>
+            Used to convert objects to the <see cref="T:log4net.Layout.IRawLayout"/> interface.
+            Supports converting from the <see cref="T:log4net.Layout.ILayout"/> interface to
+            the <see cref="T:log4net.Layout.IRawLayout"/> interface using the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertFrom">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from arbitrary types
+            to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to the
+            type supported by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> to the type supported
+            by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the sourceType be converted to an <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <param name="sourceType">the source to be to be converted</param>
+            <returns><c>true</c> if the source type can be converted to <see cref="T:log4net.Layout.IRawLayout"/></returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to a
+            <see cref="T:log4net.Layout.IRawLayout"/>. Only <see cref="T:log4net.Layout.ILayout"/> is supported
+            as the <paramref name="sourceType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the value to a <see cref="T:log4net.Layout.IRawLayout"/> object
+            </summary>
+            <param name="source">the value to convert</param>
+            <returns>the <see cref="T:log4net.Layout.IRawLayout"/> object</returns>
+            <remarks>
+            <para>
+            Convert the <paramref name="source"/> object to a 
+            <see cref="T:log4net.Layout.IRawLayout"/> object. If the <paramref name="source"/> object
+            is a <see cref="T:log4net.Layout.ILayout"/> then the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>
+            is used to adapt between the two interfaces, otherwise an
+            exception is thrown.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawPropertyLayout">
+            <summary>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.#ctor">
+            <summary>
+            Constructs a RawPropertyLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Lookup the property for <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns property value</returns>
+            <remarks>
+            <para>
+            Looks up and returns the object value of the property
+            named <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>. If there is no property defined
+            with than name then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.RawPropertyLayout.Key">
+            <summary>
+            The name of the value to lookup in the LoggingEvent Properties collection.
+            </summary>
+            <value>
+            Value to lookup in the LoggingEvent Properties collection
+            </value>
+            <remarks>
+            <para>
+            String name of the property to lookup in the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in local time. To format the time stamp
+            in universal time use <see cref="T:log4net.Layout.RawUtcTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawUtcTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawUtcTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in universal time. To format the time stamp
+            in local time use <see cref="T:log4net.Layout.RawTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.SimpleLayout">
+            <summary>
+            A very simple layout
+            </summary>
+            <remarks>
+            <para>
+            SimpleLayout consists of the level of the log statement,
+            followed by " - " and then the log message itself. For example,
+            <code>
+            DEBUG - Hello world
+            </code>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.#ctor">
+            <summary>
+            Constructs a SimpleLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a simple formatted output.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Formats the event as the level of the even,
+            followed by " - " and then the log message itself. The
+            output is terminated by a newline.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayout">
+             <summary>
+             Layout that formats the log events as XML elements.
+             </summary>
+             <remarks>
+             <para>
+             The output of the <see cref="T:log4net.Layout.XmlLayout"/> consists of a series of 
+             log4net:event elements. It does not output a complete well-formed XML 
+             file. The output is designed to be included as an <em>external entity</em>
+             in a separate file to form a correct XML file.
+             </para>
+             <para>
+             For example, if <c>abc</c> is the name of the file where
+             the <see cref="T:log4net.Layout.XmlLayout"/> output goes, then a well-formed XML file would 
+             be:
+             </para>
+             <code lang="XML">
+             &lt;?xml version="1.0" ?&gt;
+             
+             &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;
+            
+             &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;
+                 &amp;data;
+             &lt;/log4net:events&gt;
+             </code>
+             <para>
+             This approach enforces the independence of the <see cref="T:log4net.Layout.XmlLayout"/> 
+             and the appender where it is embedded.
+             </para>
+             <para>
+             The <c>version</c> attribute helps components to correctly
+             interpret output generated by <see cref="T:log4net.Layout.XmlLayout"/>. The value of 
+             this attribute should be "1.2" for release 1.2 and later.
+             </para>
+             <para>
+             Alternatively the <c>Header</c> and <c>Footer</c> properties can be
+             configured to output the correct XML header, open tag and close tag.
+             When setting the <c>Header</c> and <c>Footer</c> properties it is essential
+             that the underlying data store not be appendable otherwise the data
+             will become invalid XML.
+             </para>
+             </remarks>
+             <author>Nicko Cadell</author>
+             <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutBase">
+            <summary>
+            Layout that formats the log events as XML elements.
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract class that must be subclassed by an implementation 
+            to conform to a specific schema.
+            </para>
+            <para>
+            Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class
+            with no location info.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="locationInfo" /> parameter determines whether 
+            location information will be output by the layout. If 
+            <paramref name="locationInfo" /> is set to <c>true</c>, then the 
+            file name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the
+            <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed 
+            to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the
+            <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to format
+            the <see cref="T:log4net.Core.LoggingEvent"/> as XML.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">
+            <summary>
+            Flag to indicate if location information should be included in
+            the XML events.
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">
+            <summary>
+            The string to replace invalid chars with
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">
+            <summary>
+            Gets a value indicating whether to include location information in 
+            the XML events.
+            </summary>
+            <value>
+            <c>true</c> if location information should be included in the XML 
+            events; otherwise, <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file 
+            name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an <c>SMTPAppender</c>
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">
+            <summary>
+            The string to replace characters that can not be expressed in XML with.
+            <remarks>
+            <para>
+            Not all characters may be expressed in XML. This property contains the
+            string to replace those that can not with. This defaults to a ?. Set it
+            to the empty string to simply remove offending characters. For more
+            details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets
+            Character replacement will occur in  the log message, the property names 
+            and the property values.
+            </para>
+            </remarks>
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.ContentType">
+            <summary>
+            Gets the content type output by this layout. 
+            </summary>
+            <value>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </value>
+            <remarks>
+            <para>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor">
+            <summary>
+            Constructs an XmlLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XmlLayout.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SmtpAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Builds a cache of the element names
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Override the base class <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method
+            to write the <see cref="T:log4net.Core.LoggingEvent"/> to the <see cref="T:System.Xml.XmlWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayout.m_prefix">
+            <summary>
+            The prefix to use for all generated element names
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Prefix">
+            <summary>
+            The prefix to use for all element names
+            </summary>
+            <remarks>
+            <para>
+            The default prefix is <b>log4net</b>. Set this property
+            to change the prefix. If the prefix is set to an empty string
+            then no prefix will be written.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeMessage">
+            <summary>
+            Set whether or not to base64 encode the message.
+            </summary>
+            <remarks>
+            <para>
+            By default the log message will be written as text to the xml
+            output. This can cause problems when the message contains binary
+            data. By setting this to true the contents of the message will be
+            base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the log message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeProperties">
+            <summary>
+            Set whether or not to base64 encode the property values.
+            </summary>
+            <remarks>
+            <para>
+            By default the properties will be written as text to the xml
+            output. This can cause problems when one or more properties contain
+            binary data. By setting this to true the values of the properties
+            will be base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the property values.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutSchemaLog4j">
+            <summary>
+            Layout that formats the log events as XML elements compatible with the log4j schema
+            </summary>
+            <remarks>
+            <para>
+            Formats the log events according to the http://logging.apache.org/log4j schema.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutSchemaLog4j.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Actually do the writing of the xml
+            </summary>
+            <param name="writer">the writer to use</param>
+            <param name="loggingEvent">the event to write</param>
+            <remarks>
+            <para>
+            Generate XML that is compatible with the log4j schema.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutSchemaLog4j.Version">
+            <summary>
+            The version of the log4j schema to use.
+            </summary>
+            <remarks>
+            <para>
+            Only version 1.2 of the log4j schema is supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.DefaultRenderer">
+            <summary>
+            The default object Renderer.
+            </summary>
+            <remarks>
+            <para>
+            The default renderer supports rendering objects and collections to strings.
+            </para>
+            <para>
+            See the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)"/> method for details of the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ObjectRenderer.IObjectRenderer">
+            <summary>
+            Implement this interface in order to render objects as strings
+            </summary>
+            <remarks>
+            <para>
+            Certain types require special case conversion to
+            string form. This conversion is done by an object renderer.
+            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>
+            interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.IObjectRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a 
+            string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object, TextWriter)"/>
+            method can be used to render these objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)"/>
+            method can be used to render these objects.
+            </para>
+            <para>
+            The default renderer supports rendering objects to strings as follows:
+            </para>
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Rendered String</description>
+            	</listheader>
+            	<item>
+            		<term><c>null</c></term>
+            		<description>
+            		<para>"(null)"</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Array"/></term>
+            		<description>
+            		<para>
+            		For a one dimensional array this is the
+            		array type name, an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace. 
+            		</para>
+            		<para>
+            		For example: <c>int[] {1, 2, 3}</c>.
+            		</para>
+            		<para>
+            		If the array is not one dimensional the 
+            		<c>Array.ToString()</c> is returned.
+            		</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Collections.IEnumerable"/>, <see cref="T:System.Collections.ICollection"/> &amp; <see cref="T:System.Collections.IEnumerator"/></term>
+            		<description>
+            		<para>
+            		Rendered as an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace.
+            		</para>
+            		<para>
+            		For example: <c>{a, b, c}</c>.
+            		</para>
+            		<para>
+            		All collection classes that implement <see cref="T:System.Collections.ICollection"/> its subclasses, 
+            		or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable"/> interface.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term><see cref="T:System.Collections.DictionaryEntry"/></term>
+            		<description>
+            		<para>
+            		Rendered as the key, an equals sign ('='), and the value (using the appropriate
+            		renderer). 
+            		</para>
+            		<para>
+            		For example: <c>key=value</c>.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term>other</term>
+            		<description>
+            		<para><c>Object.ToString()</c></para>
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array,System.IO.TextWriter)">
+            <summary>
+            Render the array argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="array">the array to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            For a one dimensional array this is the
+            array type name, an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>int[] {1, 2, 3}</c>.
+            </para>
+            <para>
+            If the array is not one dimensional the 
+            <c>Array.ToString()</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderEnumerator(log4net.ObjectRenderer.RendererMap,System.Collections.IEnumerator,System.IO.TextWriter)">
+            <summary>
+            Render the enumerator argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="enumerator">the enumerator to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Rendered as an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>{a, b, c}</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderDictionaryEntry(log4net.ObjectRenderer.RendererMap,System.Collections.DictionaryEntry,System.IO.TextWriter)">
+            <summary>
+            Render the DictionaryEntry argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="entry">the DictionaryEntry to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the key, an equals sign ('='), and the value (using the appropriate
+            renderer). For example: <c>key=value</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.RendererMap">
+            <summary>
+            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a mapping between types that require special
+            rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that
+            is used to render them.
+            </para>
+            <para>
+            The <see cref="M:FindAndRender(object)"/> method is used to render an
+            <c>object</c> using the appropriate renderers defined in this map.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <returns>the object rendered as a string</returns>
+            <remarks>
+            <para>
+            This is a convenience method used to render an object to a string.
+            The alternative method <see cref="M:FindAndRender(object,TextWriter)"/>
+            should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Find the appropriate renderer for the type of the
+            <paramref name="obj"/> parameter. This is accomplished by calling the
+            <see cref="M:Get(Type)"/> method. Once a renderer is found, it is
+            applied on the object <paramref name="obj"/> and the result is returned
+            as a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
+            <summary>
+            Gets the renderer for the specified object type
+            </summary>
+            <param name="obj">the object to lookup the renderer for</param>
+            <returns>the renderer for <paramref name="obj"/></returns>
+            <remarks>
+            <param>
+            Gets the renderer for the specified object type.
+            </param>
+            <param>
+            Syntactic sugar method that calls <see cref="M:Get(Type)"/> 
+            with the type of the object parameter.
+            </param>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
+            <summary>
+            Gets the renderer for the specified type
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+            <remarks>
+            <para>
+            Returns the renderer for the specified type.
+            If no specific renderer has been defined the
+            <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">
+            <summary>
+            Internal function to recursively search interfaces
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
+            <summary>
+            Clear the map of renderers
+            </summary>
+            <remarks>
+            <para>
+            Clear the custom renderers defined by using
+            <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>
+            cannot be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>. 
+            </summary>
+            <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>
+            <param name="renderer">the renderer for <paramref name="typeToRender"/></param>
+            <remarks>
+            <para>
+            Register an object renderer for a specific source type.
+            This renderer will be returned from a call to <see cref="M:Get(Type)"/>
+            specifying the same <paramref name="typeToRender"/> as an argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
+            <summary>
+            Get the default renderer instance
+            </summary>
+            <value>the default renderer</value>
+            <remarks>
+            <para>
+            Get the default renderer
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.IPlugin">
+            <summary>
+            Interface implemented by logger repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            Plugins define additional behavior that can be associated
+            with a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The <see cref="T:log4net.Plugin.PluginMap"/> held by the <see cref="P:log4net.Repository.ILoggerRepository.PluginMap"/>
+            property is used to store the plugins for a repository.
+            </para>
+            <para>
+            The <c>log4net.Config.PluginAttribute</c> can be used to
+            attach plugins to repositories created using configuration
+            attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches the plugin to the specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.IPlugin.Name">
+            <summary>
+            Gets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ReadOnly(log4net.Plugin.PluginCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>PluginCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>PluginCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>PluginCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <c>PluginCollection</c>.
+            </summary>
+            <param name="c">The <c>PluginCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.IPlugin[])">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[])">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[],System.Int32)">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the end of the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to be added to the end of the <c>PluginCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clear">
+            <summary>
+            Removes all elements from the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Plugin.PluginCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Contains(log4net.Plugin.IPlugin)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Plugin.IPlugin"/> is in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>PluginCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IndexOf(log4net.Plugin.IPlugin)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Plugin.IPlugin"/>
+            in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to locate in the <c>PluginCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>PluginCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Insert(System.Int32,log4net.Plugin.IPlugin)">
+            <summary>
+            Inserts an element into the <c>PluginCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Plugin.IPlugin"/> from the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the <c>PluginCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Plugin.IPlugin"/> was not found in the <c>PluginCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>PluginCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>PluginCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Plugin.PluginCollection.Enumerator"/> for the entire <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.PluginCollection)">
+            <summary>
+            Adds the elements of another <c>PluginCollection</c> to the current <c>PluginCollection</c>.
+            </summary>
+            <param name="x">The <c>PluginCollection</c> whose elements should be added to the end of the current <c>PluginCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.IPlugin[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> array to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> collection to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the collection.
+            </value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </value>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value><c>true</c> if the collection has a fixed size; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value><c>true</c> if the collection is read-only; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>PluginCollection</c> can contain.
+            </summary>
+            <value>
+            The number of elements the <c>PluginCollection</c> can contain.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Plugin.PluginCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+            <value>
+            The current element in the collection.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.ReadOnlyPluginCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Plugin.PluginMap">
+            <summary>
+            Map of repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            This class is a name keyed map of the plugins that are
+            attached to a repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository that the plugins should be attached to.</param>
+            <remarks>
+            <para>
+            Initialize a new instance of the <see cref="T:log4net.Plugin.PluginMap"/> class with a 
+            repository that the plugins should be attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to add to the map.</param>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Plugin.IPlugin"/> will be attached to the repository when added.
+            </para>
+            <para>
+            If there already exists a plugin with the same name 
+            attached to the repository then the old plugin will
+            be <see cref="M:log4net.Plugin.IPlugin.Shutdown"/> and replaced with
+            the new plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes a <see cref="T:log4net.Plugin.IPlugin"/> from the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the map.</param>
+            <remarks>
+            <para>
+            Remove a specific plugin from this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.Item(System.String)">
+            <summary>
+            Gets a <see cref="T:log4net.Plugin.IPlugin"/> by name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Plugin.IPlugin"/> to lookup.</param>
+            <returns>
+            The <see cref="T:log4net.Plugin.IPlugin"/> from the map with the name specified, or 
+            <c>null</c> if no plugin is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup a plugin by name. If the plugin is not found <c>null</c>
+            will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.AllPlugins">
+            <summary>
+            Gets all possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <value>All possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.</value>
+            <remarks>
+            <para>
+            Get a collection of all the plugins defined in this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginSkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Plugin.IPlugin"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Plugin.IPlugin"/>
+            interface. This base class can be used by implementors
+            of the <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="name">the name of the plugin</param>
+            <remarks>
+            Initializes a new Plugin with the specified name.
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_name">
+            <summary>
+            The name of this plugin.
+            </summary>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_repository">
+            <summary>
+            The repository this plugin is attached to.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.Name">
+            <summary>
+            Gets or sets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            <para>
+            The name of the plugin must not change one the 
+            plugin has been attached to a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.LoggerRepository">
+            <summary>
+            The repository for this plugin
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is attached to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is 
+            attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin">
+            <summary>
+            Plugin that listens for events from the <see cref="T:log4net.Appender.RemotingAppender"/>
+            </summary>
+            <remarks>
+            <para>
+            This plugin publishes an instance of <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/> 
+            on a specified <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/>. This listens for logging events delivered from
+            a remote <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            <para>
+            When an event is received it is relogged within the attached repository
+            as if it had been raised locally.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class.
+            </para>
+            <para>
+            The <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> property must be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor(System.String)">
+            <summary>
+            Construct with sink Uri.
+            </summary>
+            <param name="sinkUri">The name to publish the sink under in the remoting infrastructure. 
+            See <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> for more details.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class
+            with specified name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            When the plugin is shutdown the remote logging
+            sink is disconnected.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.declaringType">
+            <summary>
+            The fully qualified type of the RemoteLoggingServerPlugin class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri">
+            <summary>
+            Gets or sets the URI of this sink.
+            </summary>
+            <value>
+            The URI of this sink.
+            </value>
+            <remarks>
+            <para>
+            This is the name under which the object is marshaled.
+            <see cref="M:RemotingServices.Marshal(MarshalByRefObject,String,Type)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl">
+            <summary>
+            Delivers <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to listen for logging events
+            and deliver them to the local repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository to log to.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl"/> for the
+            specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Logs the events to the repository.
+            </summary>
+            <param name="events">The events to log.</param>
+            <remarks>
+            <para>
+            The events passed are logged to the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.InitializeLifetimeService">
+            <summary>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance.
+            </summary>
+            <returns><c>null</c> to indicate that this instance should live forever.</returns>
+            <remarks>
+            <para>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance. This object should live forever
+            therefore this implementation returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.m_repository">
+            <summary>
+            The underlying <see cref="T:log4net.Repository.ILoggerRepository"/> that events should
+            be logged to.
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">
+            <summary>
+            Default implementation of <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            </summary>
+            <remarks>
+            <para>
+            This default implementation of the <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            interface is used to create the default subclass
+            of the <see cref="T:log4net.Repository.Hierarchy.Logger"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">
+            <summary>
+            Interface abstracts creation of <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances
+            </summary>
+            <remarks>
+            <para>
+            This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to 
+            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.
+            </para>
+            <para>
+            The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)"/> method is called
+            to create a named <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            <para>
+            Implement this interface to create new subclasses of <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl">
+            <summary>
+            Default internal subclass of <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            </summary>
+            <remarks>
+            <para>
+            This subclass has no additional behavior over the
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> class but does allow instances
+            to be created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Logger">
+            <summary>
+            Implementation of <see cref="T:log4net.Core.ILogger"/> used by <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to provide implementation of <see cref="T:log4net.Core.ILogger"/>
+            interface. Applications should use <see cref="T:log4net.LogManager"/> to get
+            logger instances.
+            </para>
+            <para>
+            This is one of the central classes in the log4net implementation. One of the
+            distinctive features of log4net are hierarchical loggers and their
+            evaluation. The <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> organizes the <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            instances into a rooted tree hierarchy.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.Logger"/> class is abstract. Only concrete subclasses of
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> can be created. The <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            is used to create instances of this type for the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">
+            <summary>
+            This constructor created a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance and
+            sets its name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <remarks>
+            <para>
+            This constructor is protected and designed to be used by
+            a subclass that is not abstract.
+            </para>
+            <para>
+            Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> 
+            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default
+            logger creator.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </summary>
+            <param name="newAppender">An appender to add to this logger</param>
+            <remarks>
+            <para>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </para>
+            <para>
+            If <paramref name="newAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">
+            <summary>
+            Look for the appender named as <c>name</c>
+            </summary>
+            <param name="name">The name of the appender to lookup</param>
+            <returns>The appender with the name specified, or <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Returns the named appender, or null if the appender is not found.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">
+            <summary>
+            Remove all previously added appenders from this Logger instance.
+            </summary>
+            <remarks>
+            <para>
+            Remove all previously added appenders from this Logger instance.
+            </para>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the named appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Deliver the <see cref="T:log4net.Core.LoggingEvent"/> to the attached appenders.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Call the appenders in the hierarchy starting at
+            <c>this</c>. If no appenders could be found, emit a
+            warning.
+            </para>
+            <para>
+            This method calls all the appenders inherited from the
+            hierarchy circumventing any evaluation of whether to log or not
+            to log the particular log request.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">
+            <summary>
+            Closes all attached appenders implementing the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Used to ensure that the appenders are correctly shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This is the most generic printing method. This generic form is intended to be used by wrappers
+            </summary>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generates a logging event and delivers it to the attached
+            appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.Core.LoggingEvent)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">
+            <summary>
+            The name of this logger.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">
+            <summary>
+            The assigned level of this logger. 
+            </summary>
+            <remarks>
+            <para>
+            The <c>level</c> variable need not be 
+            assigned a value in which case it is inherited 
+            form the hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">
+            <summary>
+            The parent of this logger.
+            </summary>
+            <remarks>
+            <para>
+            The parent of this logger. 
+            All loggers have at least one ancestor which is the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">
+            <summary>
+            Loggers need to know what Hierarchy they are in.
+            </summary>
+            <remarks>
+            <para>
+            Loggers need to know what Hierarchy they are in.
+            The hierarchy that this logger is a member of is stored
+            here.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderAttachedImpl">
+            <summary>
+            Helper implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">
+            <summary>
+            Flag indicating if child loggers inherit their parents appenders
+            </summary>
+            <remarks>
+            <para>
+            Additivity is set to true by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderLock">
+            <summary>
+            Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl
+            </summary>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">
+            <summary>
+            Gets or sets the parent logger in the hierarchy.
+            </summary>
+            <value>
+            The parent logger in the hierarchy.
+            </value>
+            <remarks>
+            <para>
+            Part of the Composite pattern that makes the hierarchy.
+            The hierarchy is parent linked rather than child linked.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">
+            <summary>
+            Gets or sets a value indicating if child loggers inherit their parent's appenders.
+            </summary>
+            <value>
+            <c>true</c> if child loggers inherit their parent's appenders.
+            </value>
+            <remarks>
+            <para>
+            Additivity is set to <c>true</c> by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.EffectiveLevel">
+            <summary>
+            Gets the effective level for this logger.
+            </summary>
+            <returns>The nearest level in the logger hierarchy.</returns>
+            <remarks>
+            <para>
+            Starting from this logger, searches the logger hierarchy for a
+            non-null level and returns it. Otherwise, returns the level of the
+            root logger.
+            </para>
+            <para>The Logger class is designed so that this method executes as
+            quickly as possible.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>The hierarchy that this logger belongs to.</value>
+            <remarks>
+            <para>
+            This logger must be attached to a single <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.
+            </value>
+            <remarks>
+            <para>
+            The assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> can be <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Appenders">
+            <summary>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <returns>A collection of the appenders in this logger</returns>
+            <remarks>
+            <para>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>. If no appenders 
+            can be found, then a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Name">
+            <summary>
+            Gets the logger name.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl.#ctor(System.String)">
+            <summary>
+            Construct a new Logger
+            </summary>
+            <param name="name">the name of the logger</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl"/> class
+            with the specified name. 
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
+            <summary>
+            Delegate used to handle logger creation event notifications.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> in which the <see cref="T:log4net.Repository.Hierarchy.Logger"/> has been created.</param>
+            <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args that hold the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a
+            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
+            <summary>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument 
+            class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
+            <summary>
+            Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy">
+            <summary>
+            Hierarchical organization of loggers
+            </summary>
+            <remarks>
+            <para>
+            <i>The casual user should not have to deal with this class
+            directly.</i>
+            </para>
+            <para>
+            This class is specialized in retrieving loggers by name and
+            also maintaining the logger hierarchy. Implements the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            The structure of the logger hierarchy is maintained by the
+            <see cref="M:GetLogger(string)"/> method. The hierarchy is such that children
+            link to their parent but parents do not have any references to their
+            children. Moreover, loggers can be instantiated in any order, in
+            particular descendant before ancestor.
+            </para>
+            <para>
+            In case a descendant is created before a particular ancestor,
+            then it creates a provision node for the ancestor and adds itself
+            to the provision node. Other descendants of the same ancestor add
+            themselves to the previously created provision node.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositorySkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.ILoggerRepository">
+            <summary>
+            Interface implemented by logger repositories.
+            </summary>
+            <remarks>
+            <para>
+            This interface is implemented by logger repositories. e.g. 
+            <see cref="N:log4net.Repository.Hierarchy"/>.
+            </para>
+            <para>
+            This interface is used by the <see cref="T:log4net.LogManager"/>
+            to obtain <see cref="T:log4net.ILog"/> interfaces.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
+            <summary>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If the names logger exists it is returned, otherwise
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers as an Array.
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
+            <summary>
+            Returns a named logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Returns a named logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
+            <summary>Shutdown the repository</summary>
+            <remarks>
+            <para>
+            Shutting down a repository will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <see cref="M:Shutdown()"/> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.ConfigurationMessages">
+            <summary>
+            Collection of internal messages captured during the most 
+            recent configuration process.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            <para>
+            These properties can be specified on a repository specific basis.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes the repository with default (empty) properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct the repository using specific properties
+            </summary>
+            <param name="properties">the properties to set for this repository</param>
+            <remarks>
+            <para>
+            Initializes the repository with specified properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
+            <summary>
+            Test if logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the repository
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the repository as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Return a new logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
+            <summary>
+            Shutdown the repository
+            </summary>
+            <remarks>
+            <para>
+            Shutdown the repository. Can be overridden in a subclass.
+            This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>
+            listeners and all attached plugins of the shutdown event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.LoggerRepositorySkeleton.declaringType">
+            <summary>
+            The fully qualified type of the LoggerRepositorySkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Adds an object renderer for a specific class. 
+            </summary>
+            <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>
+            <param name="rendererInstance">The object renderer used to render the object.</param>
+            <remarks>
+            <para>
+            Adds an object renderer for a specific class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository is shutting down
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository is shutting down.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration reset
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has been reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration changed
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">
+            <summary>
+            Raise a configuration changed event on this repository
+            </summary>
+            <param name="e">EventArgs.Empty</param>
+            <remarks>
+            <para>
+            Applications that programmatically change the configuration of the repository should
+            raise this event notification to notify listeners.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes all configured Appenders that implement <see cref="T:log4net.Appender.IFlushable"/>.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed,
+            or <see cref="F:System.Threading.Timeout.Infinite"/> to wait indefinitely.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The string name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of this repository. The name is
+            used to store and lookup the repositories 
+            stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.ConfigurationMessages">
+            <summary>
+            Contains a list of internal messages captures during the 
+            last configuration.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            These properties can be specified on a repository specific basis
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
+            <summary>
+            Basic Configurator interface for repositories
+            </summary>
+            <remarks>
+            <para>
+            Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>
+            with a default <see cref="T:log4net.Appender.IAppender"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the repository using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the repository using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IXmlRepositoryConfigurator">
+            <summary>
+            Configure repository using XML
+            </summary>
+            <remarks>
+            <para>
+            Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the repository using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            The schema for the XML configuration data is defined by
+            the implementation.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct with properties
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with a logger factory
+            </summary>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with properties and a logger factory
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
+            <summary>
+            Test if a logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the hierarchy. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the hierarchy as an Array
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the hierarchy as an Array.
+            The root logger is <b>not</b> included in the returned
+            enumeration.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </summary>
+            <remarks>
+            <para>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
+            <summary>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </summary>
+            <remarks>
+            <para>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <c>Shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
+            <summary>
+            Reset all values contained in this hierarchy instance to their default.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this hierarchy instance to their
+            default.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this hierarchy.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">
+            <summary>
+            Returns all the Appenders that are currently configured
+            </summary>
+            <returns>An array containing all the currently configured appenders</returns>
+            <remarks>
+            <para>
+            Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.
+            All the loggers are searched for appenders. The appenders may also be containers
+            for appenders and these are also searched for additional loggers.
+            </para>
+            <para>
+            The list returned is unordered but does not contain duplicates.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.
+            The appender may also be a container.
+            </summary>
+            <param name="appenderList"></param>
+            <param name="appender"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container
+            </summary>
+            <param name="appenderList"></param>
+            <param name="container"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the log4net system using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">
+            <summary>
+            Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="level">The level to check against.</param>
+            <returns>
+            <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.
+            </returns>
+            <remarks>
+            <para>
+            If this hierarchy has not been configured then this method will
+            always return <c>true</c>.
+            </para>
+            <para>
+            This method will return <c>true</c> if this repository is
+            disabled for <c>level</c> object passed as parameter and
+            <c>false</c> otherwise.
+            </para>
+            <para>
+            See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
+            <summary>
+            Clear all logger definitions from the internal hashtable
+            </summary>
+            <remarks>
+            <para>
+            This call will clear all logger definitions from the internal
+            hashtable. Invoking this method will irrevocably mess up the
+            logger hierarchy.
+            </para>
+            <para>
+            You should <b>really</b> know what you are doing before
+            invoking this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            <paramref name="factory"/>.
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <param name="factory">The factory that will make the new logger instance</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated by the
+            <paramref name="factory"/> parameter and linked with its existing
+            ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Sends a logger creation event to all registered listeners
+            </summary>
+            <param name="logger">The newly created logger</param>
+            <remarks>
+            Raises the logger creation event.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Updates all the parents of the specified logger
+            </summary>
+            <param name="log">The logger to update the parents for</param>
+            <remarks>
+            <para>
+            This method loops through all the <i>potential</i> parents of
+            <paramref name="log"/>. There 3 possible cases:
+            </para>
+            <list type="number">
+            	<item>
+            		<term>No entry for the potential parent of <paramref name="log"/> exists</term>
+            		<description>
+            		We create a ProvisionNode for this potential 
+            		parent and insert <paramref name="log"/> in that provision node.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type Logger for the potential parent.</term>
+            		<description>
+            		The entry is <paramref name="log"/>'s nearest existing parent. We 
+            		update <paramref name="log"/>'s parent field with this entry. We also break from 
+            		he loop because updating our parent's parent is our parent's 
+            		responsibility.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type ProvisionNode for this potential parent.</term>
+            		<description>
+            		We add <paramref name="log"/> to the list of children for this 
+            		potential parent.
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
+            </summary>
+            <param name="pn"></param>
+            <param name="log"></param>
+            <remarks>
+            <para>
+            We update the links for all the children that placed themselves
+            in the provision node 'pn'. The second argument 'log' is a
+            reference for the newly created Logger, parent of all the
+            children in 'pn'.
+            </para>
+            <para>
+            We loop on all the children 'c' in 'pn'.
+            </para>
+            <para>
+            If the child 'c' has been already linked to a child of
+            'log' then there is no need to update 'c'.
+            </para>
+            <para>
+            Otherwise, we set log's parent field to c's parent and set
+            c's parent field to log.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">
+            <summary>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="levelEntry">the level values</param>
+            <remarks>
+            <para>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </para>
+            <para>
+            Supports setting levels via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="propertyEntry">the property value</param>
+            <remarks>
+            <para>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.
+            </para>
+            <para>
+            Supports setting property values via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Hierarchy.declaringType">
+            <summary>
+            The fully qualified type of the Hierarchy class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">
+            <summary>
+            Event used to notify that a logger has been created.
+            </summary>
+            <remarks>
+            <para>
+            Event raised when a logger is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
+            <summary>
+            Has no appender warning been emitted
+            </summary>
+            <remarks>
+            <para>
+            Flag to indicate if we have already issued a warning
+            about not having an appender warning.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
+            <summary>
+            Get the root of this hierarchy
+            </summary>
+            <remarks>
+            <para>
+            Get the root of this hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
+            <summary>
+            Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.
+            </summary>
+            <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>
+            <remarks>
+            <para>
+            The logger factory is used to create logger instances.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">
+            <summary>
+            A class to hold the value, name and display name for a level
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the value, name and display name for a level
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">
+            <summary>
+            Value of the level
+            </summary>
+            <remarks>
+            <para>
+            If the value is not set (defaults to -1) the value will be looked
+            up for the current level with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">
+            <summary>
+            Name of the level
+            </summary>
+            <value>
+            The name of the level
+            </value>
+            <remarks>
+            <para>
+            The name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">
+            <summary>
+            Display name for the level
+            </summary>
+            <value>
+            The display name of the level
+            </value>
+            <remarks>
+            <para>
+            The display name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerKey">
+            <summary>
+            Used internally to accelerate hash table searches.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to improve performance of 
+            string keyed hashtables.
+            </para>
+            <para>
+            The hashcode of the string is cached for reuse.
+            The string is stored as an interned value.
+            When comparing two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> objects for equality 
+            the reference equality of the interned strings is compared.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.#ctor(System.String)">
+            <summary>
+            Construct key with string name
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> class 
+            with the specified name.
+            </para>
+            <para>
+            Stores the hashcode of the string and interns
+            the string key to optimize comparisons.
+            </para>
+            <note>
+            The Compact Framework 1.0 the <see cref="M:System.String.Intern(System.String)"/>
+            method does not work. On the Compact Framework
+            the string keys are not interned nor are they
+            compared by reference.
+            </note>
+            </remarks>
+            <param name="name">The name of the logger.</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.GetHashCode">
+            <summary>
+            Returns a hash code for the current instance.
+            </summary>
+            <returns>A hash code for the current instance.</returns>
+            <remarks>
+            <para>
+            Returns the cached hashcode.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.Equals(System.Object)">
+            <summary>
+            Determines whether two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> instances 
+            are equal.
+            </summary>
+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>.</param>
+            <returns>
+            <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>.
+            </returns>
+            <remarks>
+            <para>
+            Compares the references of the interned strings.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">
+            <summary>
+            Provision nodes are used where no logger instance has been specified
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> instances are used in the 
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> when there is no specified 
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> for that node.
+            </para>
+            <para>
+            A provision node holds a list of child loggers on behalf of
+            a logger that does not exist.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Create a new provision node with child node
+            </summary>
+            <param name="log">A child logger to add to this node.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> class 
+            with the specified child logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.RootLogger">
+            <summary>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> sits at the root of the logger hierarchy tree. 
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> is a regular <see cref="T:log4net.Repository.Hierarchy.Logger"/> except 
+            that it provides several guarantees.
+            </para>
+            <para>
+            First, it cannot be assigned a <c>null</c>
+            level. Second, since the root logger cannot have a parent, the
+            <see cref="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel"/> property always returns the value of the
+            level field without walking the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.Core.Level)">
+            <summary>
+            Construct a <see cref="T:log4net.Repository.Hierarchy.RootLogger"/>
+            </summary>
+            <param name="level">The level to assign to the root logger.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> class with
+            the specified logging level.
+            </para>
+            <para>
+            The root logger names itself as "root". However, the root
+            logger cannot be retrieved by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.RootLogger.declaringType">
+            <summary>
+            The fully qualified type of the RootLogger class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel">
+            <summary>
+            Gets the assigned level value without walking the logger hierarchy.
+            </summary>
+            <value>The assigned level value without walking the logger hierarchy.</value>
+            <remarks>
+            <para>
+            Because the root logger cannot have a parent and its level
+            must not be <c>null</c> this property just returns the
+            value of <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> for the root logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> of the root logger.
+            </value>
+            <remarks>
+            <para>
+            Setting the level of the root logger to a <c>null</c> reference
+            may have catastrophic results. We prevent this here.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator">
+            <summary>
+            Initializes the log4net environment using an XML DOM.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.#ctor(log4net.Repository.Hierarchy.Hierarchy)">
+            <summary>
+            Construct the configurator for a hierarchy
+            </summary>
+            <param name="hierarchy">The hierarchy to build.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator"/> class
+            with the specified <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </summary>
+            <param name="element">The root element to parse.</param>
+            <remarks>
+            <para>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">
+            <summary>
+            Parse appenders by IDREF.
+            </summary>
+            <param name="appenderRef">The appender ref element.</param>
+            <returns>The instance of the appender that the ref refers to.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return 
+            the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">
+            <summary>
+            Parses an appender element.
+            </summary>
+            <param name="appenderElement">The appender element.</param>
+            <returns>The appender instance or <c>null</c> when parsing failed.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return
+            the appender instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLogger(System.Xml.XmlElement)">
+            <summary>
+            Parses a logger element.
+            </summary>
+            <param name="loggerElement">The logger element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRoot(System.Xml.XmlElement)">
+            <summary>
+            Parses the root logger element.
+            </summary>
+            <param name="rootElement">The root element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses the children of a logger element.
+            </summary>
+            <param name="catElement">The category element.</param>
+            <param name="log">The logger instance.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse the child elements of a &lt;logger&gt; element.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement)">
+            <summary>
+            Parses an object renderer.
+            </summary>
+            <param name="element">The renderer element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a renderer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses a level element.
+            </summary>
+            <param name="element">The level element.</param>
+            <param name="log">The logger object to set the level on.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">
+            <summary>
+            Sets a parameter on an object.
+            </summary>
+            <param name="element">The parameter element.</param>
+            <param name="target">The object to set the parameter on.</param>
+            <remarks>
+            The parameter name must correspond to a writable property
+            on the object. The value of the parameter is a string,
+            therefore this function will attempt to set a string
+            property first. If unable to set a string property it
+            will inspect the property and its argument type. It will
+            attempt to call a static method called <c>Parse</c> on the
+            type of the property. This method will take a single
+            string argument and return a value that can be used to
+            set the property.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.HasAttributesOrElements(System.Xml.XmlElement)">
+            <summary>
+            Test if an element has no attributes or child elements
+            </summary>
+            <param name="element">the element to inspect</param>
+            <returns><c>true</c> if the element has any attributes or child elements, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.IsTypeConstructible(System.Type)">
+            <summary>
+            Test if a <see cref="T:System.Type"/> is constructible with <c>Activator.CreateInstance</c>.
+            </summary>
+            <param name="type">the type to inspect</param>
+            <returns><c>true</c> if the type is creatable using a default constructor, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindMethodInfo(System.Type,System.String)">
+            <summary>
+            Look for a method on the <paramref name="targetType"/> that matches the <paramref name="name"/> supplied
+            </summary>
+            <param name="targetType">the type that has the method</param>
+            <param name="name">the name of the method</param>
+            <returns>the method info found</returns>
+            <remarks>
+            <para>
+            The method must be a public instance method on the <paramref name="targetType"/>.
+            The method must be named <paramref name="name"/> or "Add" followed by <paramref name="name"/>.
+            The method must take a single parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string value to a target type.
+            </summary>
+            <param name="type">The type of object to convert the string to.</param>
+            <param name="value">The string value to use as the value of the object.</param>
+            <returns>
+            <para>
+            An object of type <paramref name="type"/> with value <paramref name="value"/> or 
+            <c>null</c> when the conversion could not be performed.
+            </para>
+            </returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement,System.Type,System.Type)">
+            <summary>
+            Creates an object as specified in XML.
+            </summary>
+            <param name="element">The XML element that contains the definition of the object.</param>
+            <param name="defaultTargetType">The object type to use if not explicitly specified.</param>
+            <param name="typeConstraint">The type that the returned object must be or must inherit from.</param>
+            <returns>The object or <c>null</c></returns>
+            <remarks>
+            <para>
+            Parse an XML element and create an object instance based on the configuration
+            data.
+            </para>
+            <para>
+            The type of the instance may be specified in the XML. If not
+            specified then the <paramref name="defaultTargetType"/> is used
+            as the type. However the type is specified it must support the
+            <paramref name="typeConstraint"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_appenderBag">
+            <summary>
+            key: appenderName, value: appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_hierarchy">
+            <summary>
+            The Hierarchy being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlHierarchyConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.ConfigurationChangedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.ConfigurationChangedEventArgs.#ctor(System.Collections.ICollection)">
+            <summary>
+            
+            </summary>
+            <param name="configurationMessages"></param>
+        </member>
+        <member name="P:log4net.Repository.ConfigurationChangedEventArgs.ConfigurationMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryShutdownEventHandler">
+            <summary>
+            Delegate used to handle logger repository shutdown event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository shutdown event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationResetEventHandler">
+            <summary>
+            Delegate used to handle logger repository configuration reset event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration reset.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository configuration reset event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationChangedEventHandler">
+            <summary>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration changed.</param>
+            <param name="e">Empty event arguments.</param>
+            <remarks>
+            <para>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppDomainPatternConverter">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the name of the current AppDomain to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppDomainPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes name of the current AppDomain to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppSettingPatternConverter">
+            <summary>
+            AppSetting pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads appSettings from the application configuration file.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single appSettings value. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all appSettings will be dumped as a list of key value pairs.
+            </para>
+            <para>
+            A typical use is to specify a base directory for log files, e.g.
+            <example>
+            <![CDATA[
+            <log4net>
+               <appender name="MyAppender" type="log4net.Appender.RollingFileAppender">
+                 <file type="log4net.Util.PatternString" value="appsetting{LogDirectory}MyApp.log"/>
+                  ...
+              </appender>
+            </log4net>
+            ]]>
+            </example>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppSettingPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.DatePatternConverter">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The date and time is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date and time passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter">
+            <summary>
+            Write an <see cref="T:System.Environment.SpecialFolder"/> folder path to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an special path environment folder path to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output. <see cref="P:log4net.Util.PatternConverter.Option"/>
+            should be a value in the <see cref="T:System.Environment.SpecialFolder"/> enumeration.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an special path environment folder path to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the special path environment folder path to the output <paramref name="writer"/>.
+            The name of the special path environment folder path to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentFolderPathPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentPatternConverter">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an environment variable to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the environment variable to the output <paramref name="writer"/>.
+            The name of the environment variable to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.IdentityPatternConverter">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current thread identity to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.IdentityPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the current thread identity to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.IdentityPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the IdentityPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">
+            <summary>
+            Pattern converter for literal string instances in the pattern
+            </summary>
+            <remarks>
+            <para>
+            Writes the literal string value specified in the 
+            <see cref="P:log4net.Util.PatternConverter.Option"/> property to 
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next converter in the chain
+            </summary>
+            <param name="pc">The next pattern converter in the chain</param>
+            <returns>The next pattern converter</returns>
+            <remarks>
+            <para>
+            Special case the building of the pattern converter chain
+            for <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> instances. Two adjacent
+            literals in the pattern can be represented by a single combined
+            pattern converter. This implementation detects when a 
+            <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> is added to the chain
+            after this converter and combines its value with this converter's
+            literal value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the literal to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            Override the formatting behavior to ignore the FormattingInfo
+            because we have a literal instead.
+            </para>
+            <para>
+            Writes the value of <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Convert this pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            This method is not used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.NewLinePatternConverter">
+            <summary>
+            Writes a newline to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the system dependent line terminator to the output.
+            This behavior can be overridden by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>:
+            </para>
+            <list type="definition">
+              <listheader>
+                <term>Option Value</term>
+                <description>Output</description>
+              </listheader>
+              <item>
+                <term>DOS</term>
+                <description>DOS or Windows line terminator <c>"\r\n"</c></description>
+              </item>
+              <item>
+                <term>UNIX</term>
+                <description>UNIX line terminator <c>"\n"</c></description>
+              </item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.ProcessIdPatternConverter">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current process ID to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current process ID to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the ProcessIdPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads the thread and global properties.
+            The thread properties take priority over global properties.
+            See <see cref="P:log4net.ThreadContext.Properties"/> for details of the 
+            thread properties. See <see cref="P:log4net.GlobalContext.Properties"/> for
+            details of the global properties.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single property. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all properties will be dumped as a list of key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.PropertyPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.RandomStringPatternConverter">
+            <summary>
+            A Pattern converter that generates a string of random characters
+            </summary>
+            <remarks>
+            <para>
+            The converter generates a string of random characters. By default
+            the string is length 4. This can be changed by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the string value of the length required.
+            </para>
+            <para>
+            The random characters in the string are limited to uppercase letters
+            and numbers only.
+            </para>
+            <para>
+            The random number generator used by this class is not cryptographically secure.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.s_random">
+            <summary>
+            Shared random number generator
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.m_length">
+            <summary>
+            Length of random string to generate. Default length 4.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write a randoim string to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write a randoim string to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the RandomStringPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UserNamePatternConverter">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current threads username to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UserNamePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current threads username to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UserNamePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UserNamePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter">
+            <summary>
+            Write the UTC date time to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UtcDatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date and time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date is in Universal time when it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.BooleanConverter">
+            <summary>
+            Type converter for Boolean.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <c>bool</c> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            <summary>
+            Exception base type for conversion errors.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConverterRegistry">
+            <summary>
+            Register of type converters for specific types.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a registry of type converters used to convert between
+            types.
+            </para>
+            <para>
+            Use the <see cref="M:AddConverter(Type, object)"/> and 
+            <see cref="M:AddConverter(Type, Type)"/> methods to register new converters.
+            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
+            lookup appropriate converters to use.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConverterRegistry"/> class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#cctor">
+            <summary>
+            Static constructor.
+            </summary>
+            <remarks>
+            <para>
+            This constructor defines the intrinsic type converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Object)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converter">The type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter instance for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Type)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converterType">The type of the type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter <see cref="T:System.Type"/> for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="sourceType">The type being converted from.</param>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConverterFromAttribute(System.Type)">
+            <summary>
+            Lookups the type converter to use as specified by the attributes on the 
+            destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.CreateConverterInstance(System.Type)">
+            <summary>
+            Creates the instance of the type converter.
+            </summary>
+            <param name="converterType">The type of the type converter.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            The type specified for the type converter must implement 
+            the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> or <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces 
+            and must have a public default (no argument) constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.declaringType">
+            <summary>
+            The fully qualified type of the ConverterRegistry class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.s_type2converter">
+            <summary>
+            Mapping from <see cref="T:System.Type"/> to type converter.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.EncodingConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an encoding</param>
+            <returns>the encoding</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to 
+            convert the <see cref="T:System.String"/> argument to an <see cref="T:System.Text.Encoding"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertTo">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from a single type to arbitrary types.
+            See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.CanConvertTo(System.Type)">
+            <summary>
+            Returns whether this converter can convert the object to the specified type
+            </summary>
+            <param name="targetType">A Type that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the type supported by this converter can be converted to the
+            <paramref name="targetType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> (which must be of the type supported
+            by this converter) to the <paramref name="targetType"/> specified..
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IPAddressConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an IPAddress</param>
+            <returns>the IPAddress</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Net.IPAddress.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to an <see cref="T:System.Net.IPAddress"/>.
+            If that fails then the string is resolved as a DNS hostname.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.IPAddressConverter.validIpAddressChars">
+            <summary>
+            Valid characters in an IPv4 or IPv6 address string. (Does not support subnets)
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternLayoutConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> 
+            of the <see cref="T:log4net.Layout.PatternLayout"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternLayout</param>
+            <returns>the PatternLayout</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Layout.PatternLayout"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternStringConverter">
+            <summary>
+            Convert between string and <see cref="T:log4net.Util.PatternString"/>
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Util.PatternString"/> type, 
+            and from a <see cref="T:log4net.Util.PatternString"/> type to a string.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Util.PatternString.ConversionPattern"/> 
+            of the <see cref="T:log4net.Util.PatternString"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)">
+            <summary>
+            Can the target type be converted to the type supported by this object
+            </summary>
+            <param name="targetType">A <see cref="T:System.Type"/> that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="targetType"/> is
+            assignable from a <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:PatternString.Format()"/> method to convert the
+            <see cref="T:log4net.Util.PatternString"/> argument to a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            <paramref name="targetType"/>. To check for this condition use the 
+            <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)"/> method.
+            </exception>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternString</param>
+            <returns>the PatternString</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Util.PatternString"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Util.PatternString.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a Type</param>
+            <returns>the Type</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Type"/>.
+            Additional effort is made to locate partially specified types
+            by searching the loaded assemblies.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">
+            <summary>
+            Attribute used to associate a type converter
+            </summary>
+            <remarks>
+            <para>
+            Class and Interface level attribute that specifies a type converter
+            to use with the associated type.
+            </para>
+            <para>
+            To associate a type converter with a target type apply a
+            <c>TypeConverterAttribute</c> to the target type. Specify the
+            type of the type converter on the attribute.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">
+            <summary>
+            The string type name of the type converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">
+            <summary>
+            Create a new type converter attribute for the specified type name
+            </summary>
+            <param name="typeName">The string type name of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">
+            <summary>
+            Create a new type converter attribute for the specified type
+            </summary>
+            <param name="converterType">The type of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">
+            <summary>
+            The string type name of the type converter 
+            </summary>
+            <value>
+            The string type name of the type converter 
+            </value>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.AppenderAttachedImpl">
+            <summary>
+            A straightforward implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This is the default implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/>
+            interface. Implementors of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            should aggregate an instance of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.AppenderAttachedImpl"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvents">The array of events being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.CallAppend(log4net.Appender.IAppender,log4net.Core.LoggingEvent[])">
+            <summary>
+            Calls the DoAppende method on the <see cref="T:log4net.Appender.IAppender"/> with 
+            the <see cref="T:log4net.Core.LoggingEvent"/> objects supplied.
+            </summary>
+            <param name="appender">The appender</param>
+            <param name="loggingEvents">The events</param>
+            <remarks>
+            <para>
+            If the <paramref name="appender"/> supports the <see cref="T:log4net.Appender.IBulkAppender"/>
+            interface then the <paramref name="loggingEvents"/> will be passed 
+            through using that interface. Otherwise the <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the array will be passed one at a time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="newAppender">The appender to add.</param>
+            <remarks>
+            <para>
+            If the appender is already in the list it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup an attached appender by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderList">
+            <summary>
+            List of appenders
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderArray">
+            <summary>
+            Array of appenders, used to cache the m_appenderList
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.declaringType">
+            <summary>
+            The fully qualified type of the AppenderAttachedImpl class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.AppenderAttachedImpl.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <returns>
+            A collection of attached appenders, or <c>null</c> if there
+            are no attached appenders.
+            </returns>
+            <remarks>
+            <para>
+            The read only collection of all currently attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CompositeProperties">
+            <summary>
+            This class aggregates several PropertiesDictionary collections together.
+            </summary>
+            <remarks>
+            <para>
+            Provides a dictionary style lookup over an ordered list of
+            <see cref="T:log4net.Util.PropertiesDictionary"/> collections.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CompositeProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Add(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Add a Properties Dictionary to this composite collection
+            </summary>
+            <param name="properties">the properties to add</param>
+            <remarks>
+            <para>
+            Properties dictionaries added first take precedence over dictionaries added
+            later.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Flatten">
+            <summary>
+            Flatten this composite collection into a single properties dictionary
+            </summary>
+            <returns>the flattened dictionary</returns>
+            <remarks>
+            <para>
+            Reduces the collection of ordered dictionaries to a single dictionary
+            containing the resultant values for the keys.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CompositeProperties.Item(System.String)">
+            <summary>
+            Gets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Looks up the value for the <paramref name="key"/> specified.
+            The <see cref="T:log4net.Util.PropertiesDictionary"/> collections are searched
+            in the order in which they were added to this collection. The value
+            returned is the value held by the first collection that contains
+            the specified key.
+            </para>
+            <para>
+            If none of the collections contain the specified key then
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ContextPropertiesBase">
+            <summary>
+            Base class for Context Properties implementations
+            </summary>
+            <remarks>
+            <para>
+            This class defines a basic property get set accessor
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ConverterInfo">
+            <summary>
+            Wrapper class used to map converter names to converter types
+            </summary>
+            <remarks>
+            <para>
+            Pattern converter info class used during configuration by custom
+            PatternString and PatternLayer converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.#ctor">
+            <summary>
+            default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            
+            </summary>
+            <param name="entry"></param>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Name">
+            <summary>
+            Gets or sets the name of the conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            The name of the pattern in the format string
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Type">
+            <summary>
+            Gets or sets the type of the converter
+            </summary>
+            <remarks>
+            <para>
+            The value specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.CountingQuietTextWriter">
+            <summary>
+            Subclass of <see cref="T:log4net.Util.QuietTextWriter"/> that maintains a count of 
+            the number of bytes written.
+            </summary>
+            <remarks>
+            <para>
+            This writer counts the number of bytes written.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.QuietTextWriter">
+            <summary>
+            <see cref="T:System.IO.TextWriter"/> that does not leak exceptions
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Util.QuietTextWriter"/> does not throw exceptions when things go wrong. 
+            Instead, it delegates error handling to its <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TextWriterAdapter">
+            <summary>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.TextWriterAdapter.m_writer">
+            <summary>
+            The writer to forward messages to
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Close">
+            <summary>
+            Closes the writer and releases any system resources associated with the writer
+            </summary>
+            <remarks>
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">
+            <summary>
+            Dispose this writer
+            </summary>
+            <param name="disposing">flag indicating if we are being disposed</param>
+            <remarks>
+            <para>
+            Dispose this writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Flush">
+            <summary>
+            Flushes any buffered output
+            </summary>
+            <remarks>
+            <para>
+            Clears all buffers for the writer and causes any buffered data to be written 
+            to the underlying device
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">
+            <summary>
+            Writes a character to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a character to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a character buffer to the wrapped TextWriter
+            </summary>
+            <param name="buffer">the data buffer</param>
+            <param name="index">the start index</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a character buffer to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">
+            <summary>
+            Writes a string to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a string to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Writer">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.IO.TextWriter"/>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Encoding">
+            <summary>
+            The Encoding in which the output is written
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>
+            </value>
+            <remarks>
+            <para>
+            The Encoding in which the output is written
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">
+            <summary>
+            Gets an object that controls formatting
+            </summary>
+            <value>
+            The format provider
+            </value>
+            <remarks>
+            <para>
+            Gets an object that controls formatting
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.NewLine">
+            <summary>
+            Gets or sets the line terminator string used by the TextWriter
+            </summary>
+            <value>
+            The line terminator to use
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the line terminator string used by the TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <param name="errorHandler">the error handler to report error to</param>
+            <remarks>
+            <para>
+            Create a new QuietTextWriter using a writer and error handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Writes a character to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a buffer to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output.
+            </summary>
+            <param name="value">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Writes a string to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Close">
+            <summary>
+            Closes the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_errorHandler">
+            <summary>
+            The error handler instance to pass all errors to
+            </summary>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_closed">
+            <summary>
+            Flag to indicate if this writer is closed
+            </summary>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.ErrorHandler">
+            <summary>
+            Gets or sets the error handler that all errors are passed to.
+            </summary>
+            <value>
+            The error handler that all errors are passed to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the error handler that all errors are passed to.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.Closed">
+            <summary>
+            Gets a value indicating whether this writer is closed.
+            </summary>
+            <value>
+            <c>true</c> if this writer is closed, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets a value indicating whether this writer is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to actually write to.</param>
+            <param name="errorHandler">The <see cref="T:log4net.Core.IErrorHandler"/> to report errors to.</param>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.CountingQuietTextWriter"/> class 
+            with the specified <see cref="T:System.IO.TextWriter"/> and <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output and counts the number of bytes written.
+            </summary>
+            <param name="str">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.CountingQuietTextWriter.m_countBytes">
+            <summary>
+            Total number of bytes written.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.CountingQuietTextWriter.Count">
+            <summary>
+            Gets or sets the total number of bytes written.
+            </summary>
+            <value>
+            The total number of bytes written.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the total number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CyclicBuffer">
+            <summary>
+            A fixed size rolling buffer of logging events.
+            </summary>
+            <remarks>
+            <para>
+            An array backed fixed size leaky bucket.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="maxSize">The maximum number of logging events in the buffer.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with 
+            the specified maximum number of buffered logging events.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Appends a <paramref name="loggingEvent"/> to the buffer.
+            </summary>
+            <param name="loggingEvent">The event to append to the buffer.</param>
+            <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Append an event to the buffer. If the buffer still contains free space then
+            <c>null</c> is returned. If the buffer is full then an event will be dropped
+            to make space for the new event, the event dropped is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopOldest">
+            <summary>
+            Get and remove the oldest event in the buffer.
+            </summary>
+            <returns>The oldest logging event in the buffer</returns>
+            <remarks>
+            <para>
+            Gets the oldest (first) logging event in the buffer and removes it 
+            from the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopAll">
+            <summary>
+            Pops all the logging events from the buffer into an array.
+            </summary>
+            <returns>An array of all the logging events in the buffer.</returns>
+            <remarks>
+            <para>
+            Get all the events in the buffer and clear the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Clear">
+            <summary>
+            Clear the buffer
+            </summary>
+            <remarks>
+            <para>
+            Clear the buffer of all events. The events in the buffer are lost.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">
+            <summary>
+            Gets the <paramref name="i"/>th oldest event currently in the buffer.
+            </summary>
+            <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>
+            <remarks>
+            <para>
+            If <paramref name="i"/> is outside the range 0 to the number of events
+            currently in the buffer, then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.MaxSize">
+            <summary>
+            Gets the maximum size of the buffer.
+            </summary>
+            <value>The maximum size of the buffer.</value>
+            <remarks>
+            <para>
+            Gets the maximum size of the buffer
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Length">
+            <summary>
+            Gets the number of logging events in the buffer.
+            </summary>
+            <value>The number of logging events in the buffer.</value>
+            <remarks>
+            <para>
+            This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>
+            (inclusive).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyCollection">
+            <summary>
+            An always empty <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.ICollection"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyCollection"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.EmptyCollection.s_instance">
+            <summary>
+            The singleton instance of the empty collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Instance">
+            <summary>
+            Gets the singleton instance of the empty collection.
+            </summary>
+            <returns>The singleton instance of the empty collection.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the empty collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyCollection.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyCollection.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyDictionary">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionary"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyDictionary"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Add(System.Object,System.Object)">
+            <summary>
+            Adds an element with the provided key and value to the 
+            <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>
+            <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>
+            <remarks>
+            <para>
+            As the collection is empty no new values can be added. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Clear">
+            <summary>
+            Removes all elements from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Contains(System.Object)">
+            <summary>
+            Determines whether the <see cref="T:log4net.Util.EmptyDictionary"/> contains an element 
+            with the specified key.
+            </summary>
+            <param name="key">The key to locate in the <see cref="T:log4net.Util.EmptyDictionary"/>.</param>
+            <returns><c>false</c></returns>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="M:log4net.Util.EmptyDictionary.Contains(System.Object)"/> method always returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Remove(System.Object)">
+            <summary>
+            Removes the element with the specified key from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The key of the element to remove.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="F:log4net.Util.EmptyDictionary.s_instance">
+            <summary>
+            The singleton instance of the empty dictionary.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <b>true</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyDictionary.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyDictionary.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> has a fixed size.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsFixedSize"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> is read-only.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsReadOnly"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Keys">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Values">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Item(System.Object)">
+            <summary>
+            Gets or sets the element with the specified key.
+            </summary>
+            <param name="key">The key of the element to get or set.</param>
+            <value><c>null</c></value>
+            <remarks>
+            <para>
+            As the collection is empty no values can be looked up or stored. 
+            If the index getter is called then <c>null</c> is returned.
+            A <see cref="T:System.InvalidOperationException"/> is thrown if the setter is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="T:log4net.Util.FormattingInfo">
+            <summary>
+            Contain the information obtained when parsing formatting modifiers 
+            in conversion modifiers.
+            </summary>
+            <remarks>
+            <para>
+            Holds the formatting information extracted from the format string by
+            the <see cref="T:log4net.Util.PatternParser"/>. This is used by the <see cref="T:log4net.Util.PatternConverter"/>
+            objects when rendering the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor">
+            <summary>
+            Defaut Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor(System.Int32,System.Int32,System.Boolean)">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class
+            with the specified parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Min">
+            <summary>
+            Gets or sets the minimum value.
+            </summary>
+            <value>
+            The minimum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the minimum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Max">
+            <summary>
+            Gets or sets the maximum value.
+            </summary>
+            <value>
+            The maximum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the maximum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.LeftAlign">
+            <summary>
+            Gets or sets a flag indicating whether left align is enabled
+            or not.
+            </summary>
+            <value>
+            A flag indicating whether left align is enabled or not.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a flag indicating whether left align is enabled or not.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.GlobalContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.GlobalContext"/>
+            </summary>
+            <remarks>
+            <para>
+            This class implements a properties collection that is thread safe and supports both
+            storing properties and capturing a read only copy of the current propertied.
+            </para>
+            <para>
+            This class is optimized to the scenario where the properties are read frequently
+            and are modified infrequently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_readOnlyProperties">
+            <summary>
+            The read only copy of the properties.
+            </summary>
+            <remarks>
+            <para>
+            This variable is declared <c>volatile</c> to prevent the compiler and JIT from
+            reordering reads and writes of this thread performed on different threads.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_syncRoot">
+            <summary>
+            Lock object used to synchronize updates within this instance
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.GlobalContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property from the global context
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Removing an entry from the global context properties is relatively expensive compared
+            with reading a value. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Clear">
+            <summary>
+            Clear the global context properties
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.GetReadOnlyProperties">
+            <summary>
+            Get a readonly immutable copy of the properties
+            </summary>
+            <returns>the current global context properties</returns>
+            <remarks>
+            <para>
+            This implementation is fast because the GlobalContextProperties class
+            stores a readonly copy of the properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.GlobalContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Reading the value for a key is faster than setting the value.
+            When the value is written a new read only copy of 
+            the properties is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ILogExtensions">
+            <summary>
+            The static class ILogExtensions contains a set of widely used
+            methods that ease the interaction with the ILog interface implementations.
+            </summary>
+            <remarks>
+            <para>
+            This class contains methods for logging at different levels and checks the
+            properties for determining if those logging levels are enabled in the current
+            configuration.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            using log4net.Util;
+            
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.InfoExt("Application Start");
+            log.DebugExt("This is a debug message");
+            </code>
+            </example>
+        </member>
+        <member name="F:log4net.Util.ILogExtensions.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="T:log4net.Util.LevelMapping">
+            <summary>
+            Manages a mapping from levels to <see cref="T:log4net.Util.LevelMappingEntry"/>
+            </summary>
+            <remarks>
+            <para>
+            Manages an ordered mapping from <see cref="T:log4net.Core.Level"/> instances 
+            to <see cref="T:log4net.Util.LevelMappingEntry"/> subclasses.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialise a new instance of <see cref="T:log4net.Util.LevelMapping"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Add(log4net.Util.LevelMappingEntry)">
+            <summary>
+            Add a <see cref="T:log4net.Util.LevelMappingEntry"/> to this mapping
+            </summary>
+            <param name="entry">the entry to add</param>
+            <remarks>
+            <para>
+            If a <see cref="T:log4net.Util.LevelMappingEntry"/> has previously been added
+            for the same <see cref="T:log4net.Core.Level"/> then that entry will be 
+            overwritten.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Lookup(log4net.Core.Level)">
+            <summary>
+            Lookup the mapping for the specified level
+            </summary>
+            <param name="level">the level to lookup</param>
+            <returns>the <see cref="T:log4net.Util.LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
+            <remarks>
+            <para>
+            Lookup the value for the specified level. Finds the nearest
+            mapping value for the level that is equal to or less than the
+            <paramref name="level"/> specified.
+            </para>
+            <para>
+            If no mapping could be found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.ActivateOptions">
+            <summary>
+            Initialize options
+            </summary>
+            <remarks>
+            <para>
+            Caches the sorted list of <see cref="T:log4net.Util.LevelMappingEntry"/> in an array
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            <para>
+            This class stores its properties in a slot on the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> named
+            <c>log4net.Util.LogicalThreadContextProperties</c>.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.m_disabled">
+            <summary>
+            Flag used to disable this context if we don't have permission to access the CallContext.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the value for the specified <paramref name="key"/> from the context.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Clear">
+            <summary>
+            Clear all the context properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all the context properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the PropertiesDictionary stored in the LocalDataStoreSlot for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doings so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetLogicalProperties">
+            <summary>
+            Gets the call context get data.
+            </summary>
+            <returns>The peroperties dictionary stored in the call context</returns>
+            <remarks>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.GetData(System.String)"/> has a
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.SetLogicalProperties(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Sets the call context data.
+            </summary>
+            <param name="properties">The properties.</param>
+            <remarks>
+            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
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.declaringType">
+            <summary>
+            The fully qualified type of the LogicalThreadContextProperties class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Get or set the property value for the <paramref name="key"/> specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TwoArgAction`2">
+            <summary>
+            Delegate type used for LogicalThreadContextStack's callbacks.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_propertyKey">
+            <summary>
+            The name of this <see cref="T:log4net.Util.LogicalThreadContextStack"/> within the
+            <see cref="T:log4net.Util.LogicalThreadContextProperties"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_registerNew">
+            <summary>
+            The callback used to let the <see cref="T:log4net.Util.LogicalThreadContextStacks"/> register a
+            new instance of a <see cref="T:log4net.Util.LogicalThreadContextStack"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.#ctor(System.String,log4net.Util.TwoArgAction{System.String,log4net.Util.LogicalThreadContextStack})">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this thread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.LogicalThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.LogicalThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_logicalThreadContextStack">
+            <summary>
+            The outer LogicalThreadContextStack.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.#ctor(log4net.Util.LogicalThreadContextStack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="logicalThreadContextStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStacks.#ctor(log4net.Util.LogicalThreadContextProperties)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventHandler">
+            <summary>
+            
+            </summary>
+            <param name="source"></param>
+            <param name="e"></param>
+        </member>
+        <member name="T:log4net.Util.LogLog">
+            <summary>
+            Outputs log statements from within the log4net assembly.
+            </summary>
+            <remarks>
+            <para>
+            Log4net components cannot make log4net logging calls. However, it is
+            sometimes useful for the user to learn about what log4net is
+            doing.
+            </para>
+            <para>
+            All log4net internal debug calls go to the standard output stream
+            whereas internal error messages are sent to the standard error output 
+            stream.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.LogLog.ToString">
+            <summary>
+            Formats Prefix, Source, and Message in the same format as the value
+            sent to Console.Out and Trace.Write.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.LogLog.#ctor(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogLog"/> class. 
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.#cctor">
+            <summary>
+            Static constructor that initializes logging by reading 
+            settings from the application configuration file.
+            </summary>
+            <remarks>
+            <para>
+            The <c>log4net.Internal.Debug</c> application setting
+            controls internal debugging. This setting should be set
+            to <c>true</c> to enable debugging.
+            </para>
+            <para>
+            The <c>log4net.Internal.Quiet</c> application setting
+            suppresses all internal logging including error messages. 
+            This setting should be set to <c>true</c> to enable message
+            suppression.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.OnLogReceived(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Raises the LogReceived event when an internal messages is received.
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source"></param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal error messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitOutLine(System.String)">
+            <summary>
+            Writes output to the standard output stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Out and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitErrorLine(System.String)">
+            <summary>
+            Writes output to the standard error stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Error and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_debugEnabled">
+            <summary>
+             Default debug level
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_quietMode">
+            <summary>
+            In quietMode not even errors generate any output.
+            </summary>
+        </member>
+        <member name="E:log4net.Util.LogLog.LogReceived">
+            <summary>
+            The event raised when an internal message has been received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Source">
+            <summary>
+            The Type that generated the internal message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStamp">
+            <summary>
+            The DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStampUtc">
+            <summary>
+            The UTC DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Prefix">
+            <summary>
+            A string indicating the severity of the internal message.
+            </summary>
+            <remarks>
+            "log4net: ", 
+            "log4net:ERROR ", 
+            "log4net:WARN "
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.Message">
+            <summary>
+            The internal log message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Exception">
+            <summary>
+            The Exception related to the message.
+            </summary>
+            <remarks>
+            Optional. Will be null if no Exception was passed.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.InternalDebugging">
+            <summary>
+            Gets or sets a value indicating whether log4net internal logging
+            is enabled or disabled.
+            </summary>
+            <value>
+            <c>true</c> if log4net internal logging is enabled, otherwise 
+            <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c>, internal debug level logging will be 
+            displayed.
+            </para>
+            <para>
+            This value can be set by setting the application setting 
+            <c>log4net.Internal.Debug</c> in the application configuration
+            file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. debugging is
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            The following example enables internal debugging using the 
+            application configuration file :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Debug" value="true" />
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.QuietMode">
+            <summary>
+            Gets or sets a value indicating whether log4net should generate no output
+            from internal logging, not even for errors. 
+            </summary>
+            <value>
+            <c>true</c> if log4net should generate no output at all from internal 
+            logging, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c> will cause internal logging at all levels to be 
+            suppressed. This means that no warning or error reports will be logged. 
+            This option overrides the <see cref="P:log4net.Util.LogLog.InternalDebugging"/> setting and 
+            disables all debug also.
+            </para>
+            <para>This value can be set by setting the application setting
+            <c>log4net.Internal.Quiet</c> in the application configuration file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. internal logging is not
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            The following example disables internal logging using the 
+            application configuration file :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Quiet" value="true"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.EmitInternalMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsDebugEnabled">
+            <summary>
+            Test if LogLog.Debug is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Debug is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Debug is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsWarnEnabled">
+            <summary>
+            Test if LogLog.Warn is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Warn is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Warn is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsErrorEnabled">
+            <summary>
+            Test if LogLog.Error is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Error is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Error is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogLog.LogReceivedAdapter">
+            <summary>
+            Subscribes to the LogLog.LogReceived event and stores messages
+            to the supplied IList instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.#ctor(System.Collections.IList)">
+            <summary>
+            
+            </summary>
+            <param name="items"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.Dispose">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.LogReceivedAdapter.Items">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogReceivedEventArgs.#ctor(log4net.Util.LogLog)">
+            <summary>
+            
+            </summary>
+            <param name="loglog"></param>
+        </member>
+        <member name="P:log4net.Util.LogReceivedEventArgs.LogLog">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.NativeError">
+            <summary>
+            Represents a native error code and message.
+            </summary>
+            <remarks>
+            <para>
+            Represents a Win32 platform native error.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NativeError.#ctor(System.Int32,System.String)">
+            <summary>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </summary>
+            <param name="number">The number of the native error.</param>
+            <param name="message">The message of the native error.</param>
+            <remarks>
+            <para>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetLastError">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class for the last Windows error.
+            </summary>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the last windows error.
+            </returns>
+            <remarks>
+            <para>
+            The message for the <see cref="M:System.Runtime.InteropServices.Marshal.GetLastWin32Error"/> error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetError(System.Int32)">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class.
+            </summary>
+            <param name="number">the error number for the native error</param>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the specified 
+            error number.
+            </returns>
+            <remarks>
+            <para>
+            The message for the specified error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetErrorMessage(System.Int32)">
+            <summary>
+            Retrieves the message corresponding with a Win32 message identifier.
+            </summary>
+            <param name="messageId">Message identifier for the requested message.</param>
+            <returns>
+            The message corresponding with the specified message identifier.
+            </returns>
+            <remarks>
+            <para>
+            The message will be searched for in system message-table resource(s)
+            using the native <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.ToString">
+            <summary>
+            Return error information string
+            </summary>
+            <returns>error information string</returns>
+            <remarks>
+            <para>
+            Return error information string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.FormatMessage(System.Int32,System.IntPtr@,System.Int32,System.Int32,System.String@,System.Int32,System.IntPtr)">
+            <summary>
+            Formats a message string.
+            </summary>
+            <param name="dwFlags">Formatting options, and how to interpret the <paramref name="lpSource" /> parameter.</param>
+            <param name="lpSource">Location of the message definition.</param>
+            <param name="dwMessageId">Message identifier for the requested message.</param>
+            <param name="dwLanguageId">Language identifier for the requested message.</param>
+            <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>
+            <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>
+            <param name="Arguments">Pointer to an array of values that are used as insert values in the formatted message.</param>
+            <remarks>
+            <para>
+            The function requires a message definition as input. The message definition can come from a 
+            buffer passed into the function. It can come from a message table resource in an 
+            already-loaded module. Or the caller can ask the function to search the system's message 
+            table resource(s) for the message definition. The function finds the message definition 
+            in a message table resource based on a message identifier and a language identifier. 
+            The function copies the formatted message text to an output buffer, processing any embedded 
+            insert sequences if requested.
+            </para>
+            <para>
+            To prevent the usage of unsafe code, this stub does not support inserting values in the formatted message.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is the number of TCHARs stored in the output 
+            buffer, excluding the terminating null character.
+            </para>
+            <para>
+            If the function fails, the return value is zero. To get extended error information, 
+            call <see cref="M:Marshal.GetLastWin32Error()" />.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Util.NativeError.Number">
+            <summary>
+            Gets the number of the native error.
+            </summary>
+            <value>
+            The number of the native error.
+            </value>
+            <remarks>
+            <para>
+            Gets the number of the native error.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NativeError.Message">
+            <summary>
+            Gets the message of the native error.
+            </summary>
+            <value>
+            The message of the native error.
+            </value>
+            <remarks>
+            <para>
+            </para>
+            Gets the message of the native error.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.NullDictionaryEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionaryEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionaryEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance.
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullDictionaryEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullDictionaryEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullDictionaryEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Key">
+            <summary>
+            Gets the current key from the enumerator.
+            </summary>
+            <remarks>
+            Throws an exception because the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>
+            never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Key"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Value">
+            <summary>
+            Gets the current value from the enumerator.
+            </summary>
+            <value>The current value from the enumerator.</value>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Value"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Entry">
+            <summary>
+            Gets the current entry from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current entry.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Entry"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Instance">
+            <summary>
+            Get the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullSecurityContext">
+            <summary>
+            A SecurityContext used when a SecurityContext is not required
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Util.NullSecurityContext"/> is a no-op implementation of the
+            <see cref="T:log4net.Core.SecurityContext"/> base class. It is used where a <see cref="T:log4net.Core.SecurityContext"/>
+            is required but one has not been provided.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.NullSecurityContext.Instance">
+            <summary>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            <para>
+            Private constructor for singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns><c>null</c></returns>
+            <remarks>
+            <para>
+            No impersonation is done and <c>null</c> is always returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OnlyOnceErrorHandler">
+            <summary>
+            Implements log4net's default error handling policy which consists 
+            of emitting a message for the first error in an appender and 
+            ignoring all subsequent errors.
+            </summary>
+            <remarks>
+            <para>
+            The error message is processed using the LogLog sub-system by default.
+            </para>
+            <para>
+            This policy aims at protecting an otherwise working application
+            from being flooded with error messages when logging fails.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="prefix">The prefix to use for each message.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class
+            with the specified prefix.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Reset">
+            <summary>
+            Reset the error handler back to its initial disabled state.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log the very first error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            Sends the error information to <see cref="T:log4net.Util.LogLog"/>'s Error method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">
+            <summary>
+            Log an error
+            </summary>
+            <param name="message">The error message.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_enabledDateUtc">
+            <summary>
+            The UTC date the error was recorded.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">
+            <summary>
+            Flag to indicate if it is the first error
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_message">
+            <summary>
+            The message recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_exception">
+            <summary>
+            The exception recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_errorCode">
+            <summary>
+            The error code recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">
+            <summary>
+            String to prefix each message with
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.declaringType">
+            <summary>
+            The fully qualified type of the OnlyOnceErrorHandler class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">
+            <summary>
+            Is error logging enabled
+            </summary>
+            <remarks>
+            <para>
+            Is error logging enabled. Logging is only enabled for the
+            first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDate">
+            <summary>
+            The date the first error that trigged this error handler occurred, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDateUtc">
+            <summary>
+            The UTC date the first error that trigged this error handler occured, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorMessage">
+            <summary>
+            The message from the first error that trigged this error handler.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.Exception">
+            <summary>
+            The exception from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            May be <see langword="null" />.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorCode">
+            <summary>
+            The error code from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            Defaults to <see cref="F:log4net.Core.ErrorCode.GenericFailure"/>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OptionConverter">
+            <summary>
+            A convenience class to convert property values to specific types.
+            </summary>
+            <remarks>
+            <para>
+            Utility functions for converting types and parsing values.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.OptionConverter"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToBoolean(System.String,System.Boolean)">
+            <summary>
+            Converts a string to a <see cref="T:System.Boolean"/> value.
+            </summary>
+            <param name="argValue">String to convert.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Boolean"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            If <paramref name="argValue"/> is "true", then <c>true</c> is returned. 
+            If <paramref name="argValue"/> is "false", then <c>false</c> is returned. 
+            Otherwise, <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToFileSize(System.String,System.Int64)">
+            <summary>
+            Parses a file size into a number.
+            </summary>
+            <param name="argValue">String to parse.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Int64"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            Parses a file size of the form: number[KB|MB|GB] into a
+            long value. It is scaled with the appropriate multiplier.
+            </para>
+            <para>
+            <paramref name="defaultValue"/> is returned when <paramref name="argValue"/>
+            cannot be converted to a <see cref="T:System.Int64"/> value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string to an object.
+            </summary>
+            <param name="target">The target type to convert to.</param>
+            <param name="txt">The string to convert to an object.</param>
+            <returns>
+            The object converted from a string or <c>null</c> when the 
+            conversion failed.
+            </returns>
+            <remarks>
+            <para>
+            Converts a string to an object. Uses the converter registry to try
+            to convert the string value into the specified target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.CanConvertTypeTo(System.Type,System.Type)">
+            <summary>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            </summary>
+            <param name="sourceType">The type to convert from.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns><c>true</c> if there is a conversion from the source type to the target type.</returns>
+            <remarks>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertTypeTo(System.Object,System.Type)">
+            <summary>
+            Converts an object to the target type.
+            </summary>
+            <param name="sourceInstance">The object to convert to the target type.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns>The converted object.</returns>
+            <remarks>
+            <para>
+            Converts an object to the target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">
+            <summary>
+            Instantiates an object given a class name.
+            </summary>
+            <param name="className">The fully qualified class name of the object to instantiate.</param>
+            <param name="superClass">The class to which the new object should belong.</param>
+            <param name="defaultValue">The object to return in case of non-fulfillment.</param>
+            <returns>
+            An instance of the <paramref name="className"/> or <paramref name="defaultValue"/>
+            if the object could not be instantiated.
+            </returns>
+            <remarks>
+            <para>
+            Checks that the <paramref name="className"/> is a subclass of
+            <paramref name="superClass"/>. If that test fails or the object could
+            not be instantiated, then <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.SubstituteVariables(System.String,System.Collections.IDictionary)">
+            <summary>
+            Performs variable substitution in string <paramref name="value"/> from the 
+            values of keys found in <paramref name="props"/>.
+            </summary>
+            <param name="value">The string on which variable substitution is performed.</param>
+            <param name="props">The dictionary to use to lookup variables.</param>
+            <returns>The result of the substitutions.</returns>
+            <remarks>
+            <para>
+            The variable substitution delimiters are <b>${</b> and <b>}</b>.
+            </para>
+            <para>
+            For example, if props contains <c>key=value</c>, then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of key is ${key}.");
+            </code>
+            </para>
+            <para>
+            will set the variable <c>s</c> to "Value of key is value.".
+            </para>
+            <para>
+            If no value could be found for the specified key, then substitution 
+            defaults to an empty string.
+            </para>
+            <para>
+            For example, if system properties contains no value for the key
+            "nonExistentKey", then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of nonExistentKey is [${nonExistentKey}]");
+            </code>
+            </para>
+            <para>
+            will set <s>s</s> to "Value of nonExistentKey is []".	 
+            </para>
+            <para>
+            An Exception is thrown if <paramref name="value"/> contains a start 
+            delimiter "${" which is not balanced by a stop delimiter "}". 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ParseEnum(System.Type,System.String,System.Boolean)">
+            <summary>
+            Converts the string representation of the name or numeric value of one or 
+            more enumerated constants to an equivalent enumerated object.
+            </summary>
+            <param name="enumType">The type to convert to.</param>
+            <param name="value">The enum string value.</param>
+            <param name="ignoreCase">If <c>true</c>, ignore case; otherwise, regard case.</param>
+            <returns>An object of type <paramref name="enumType" /> whose value is represented by <paramref name="value" />.</returns>
+        </member>
+        <member name="F:log4net.Util.OptionConverter.declaringType">
+            <summary>
+            The fully qualified type of the OptionConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser">
+            <summary>
+            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class
+            is delegated to the PatternParser class.
+            </summary>
+            <remarks>
+            <para>
+            The <c>PatternParser</c> processes a pattern string and
+            returns a chain of <see cref="T:log4net.Util.PatternConverter"/> objects.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.PatternParser.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="pattern">The pattern to parse.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternParser"/> class 
+            with the specified pattern string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.Parse">
+            <summary>
+            Parses the pattern into a chain of pattern converters.
+            </summary>
+            <returns>The head of a chain of pattern converters.</returns>
+            <remarks>
+            <para>
+            Parses the pattern into a chain of pattern converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.BuildCache">
+            <summary>
+            Build the unified cache of converters from the static and instance maps
+            </summary>
+            <returns>the list of all the converter names</returns>
+            <remarks>
+            <para>
+            Build the unified cache of converters from the static and instance maps
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ParseInternal(System.String,System.String[])">
+            <summary>
+            Internal method to parse the specified pattern to find specified matches
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <param name="matches">the converter names to match in the pattern</param>
+            <remarks>
+            <para>
+            The matches param must be sorted such that longer strings come before shorter ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessLiteral(System.String)">
+            <summary>
+            Process a parsed literal
+            </summary>
+            <param name="text">the literal text</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessConverter(System.String,System.String,log4net.Util.FormattingInfo)">
+            <summary>
+            Process a parsed converter pattern
+            </summary>
+            <param name="converterName">the name of the converter</param>
+            <param name="option">the optional option for the converter</param>
+            <param name="formattingInfo">the formatting info for the converter</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.AddConverter(log4net.Util.PatternConverter)">
+            <summary>
+            Resets the internal state of the parser and adds the specified pattern converter 
+            to the chain.
+            </summary>
+            <param name="pc">The pattern converter to add.</param>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_head">
+            <summary>
+            The first pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_tail">
+            <summary>
+             the last pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_pattern">
+            <summary>
+            The pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_patternConverters">
+            <summary>
+            Internal map of converter identifiers to converter types
+            </summary>
+            <remarks>
+            <para>
+            This map overrides the static s_globalRulesRegistry map.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternParser.declaringType">
+            <summary>
+            The fully qualified type of the PatternParser class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternParser.PatternConverters">
+            <summary>
+            Get the converter registry used by this parser
+            </summary>
+            <value>
+            The converter registry used by this parser
+            </value>
+            <remarks>
+            <para>
+            Get the converter registry used by this parser
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser.StringLengthComparer">
+            <summary>
+            Sort strings by length
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:System.Collections.IComparer"/> that orders strings by string length.
+            The longest strings are placed first
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternString">
+            <summary>
+            This class implements a patterned string.
+            </summary>
+            <remarks>
+            <para>
+            This string has embedded patterns that are resolved and expanded
+            when the string is formatted.
+            </para>
+            <para>
+            This class functions similarly to the <see cref="T:log4net.Layout.PatternLayout"/>
+            in that it accepts a pattern and renders it to a string. Unlike the 
+            <see cref="T:log4net.Layout.PatternLayout"/> however the <c>PatternString</c>
+            does not render the properties of a specific <see cref="T:log4net.Core.LoggingEvent"/> but
+            of the process in general.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+                        <para>
+                        Used to output the friendly name of the current AppDomain.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>appsetting</term>
+                    <description>
+                        <para>
+                        Used to output the value of a specific appSetting key in the application
+                        configuration file.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>date</term>
+                    <description>
+            			<para>
+            			Used to output the current date and time in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>env</term>
+                    <description>
+                        <para>
+            			Used to output the a specific environment variable. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%env{COMPUTERNAME}</b> would include the value
+            			of the <c>COMPUTERNAME</c> environment variable.
+                        </para>
+                        <para>
+                        The <c>env</c> pattern is not supported on the .NET Compact Framework.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>identity</term>
+                    <description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>newline</term>
+                    <description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern name offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+                    </description>
+                </item>
+                <item>
+                    <term>processid</term>
+                    <description>
+                        <para>
+            			Used to output the system process ID for the current process.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>property</term>
+                    <description>
+            			<para>
+            			Used to output a specific context property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are stored in logging contexts. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+                    </description>
+                </item>
+                <item>
+                    <term>random</term>
+                    <description>
+                        <para>
+                        Used to output a random string of characters. The string is made up of
+                        uppercase letters and numbers. By default the string is 4 characters long.
+                        The length of the string can be specified within braces directly following the
+            			pattern specifier, e.g. <b>%random{8}</b> would output an 8 character string.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>username</term>
+                    <description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>utcdate</term>
+                    <description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Util.PatternString"/>
+            instance using <see cref="M:AddConverter(ConverterInfo)"/> or
+            <see cref="M:AddConverter(string, Type)"/>.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.PatternLayout"/> for details on the 
+            <i>format modifiers</i> supported by the patterns.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternString.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternString only
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor(System.String)">
+            <summary>
+            Constructs a PatternString
+            </summary>
+            <param name="pattern">The pattern to use with this PatternString</param>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/> with the pattern specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.ActivateOptions">
+            <summary>
+            Initialize object options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternString.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternString.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternString.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.CreatePatternParser(System.String)">
+            <summary>
+            Create the <see cref="T:log4net.Util.PatternParser"/> used to parse the pattern
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/></returns>
+            <remarks>
+            <para>
+            Returns PatternParser used to parse the conversion string. Subclasses
+            may override this to return a subclass of PatternParser which recognize
+            custom conversion pattern name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format(System.IO.TextWriter)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the pattern to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format">
+            <summary>
+            Format the pattern as a string
+            </summary>
+            <returns>the pattern formatted as a string</returns>
+            <remarks>
+            <para>
+            Format the pattern to a string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a converter to this PatternString
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternString.ConversionPattern">
+            <summary>
+            Gets or sets the pattern formatting string
+            </summary>
+            <value>
+            The pattern formatting string
+            </value>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PropertiesDictionary">
+            <summary>
+            String keyed object map.
+            </summary>
+            <remarks>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.ReadOnlyPropertiesDictionary">
+            <summary>
+            String keyed object map that is read only.
+            </summary>
+            <remarks>
+            <para>
+            This collection is readonly and cannot be modified.
+            </para>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.ReadOnlyPropertiesDictionary.m_hashtable">
+            <summary>
+            The Hashtable used to store the properties data
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Copy Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Deserialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetKeys">
+            <summary>
+            Gets the key names.
+            </summary>
+            <returns>An array of all the keys.</returns>
+            <remarks>
+            <para>
+            Gets the key names.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Contains(System.String)">
+            <summary>
+            Test if the dictionary contains a specified key
+            </summary>
+            <param name="key">the key to look for</param>
+            <returns>true if the dictionary contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if the dictionary contains a specified key
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <param name="value"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.InnerHashtable">
+            <summary>
+            The hashtable used to store the properties
+            </summary>
+            <value>
+            The internal collection used to store the properties
+            </value>
+            <remarks>
+            <para>
+            The hashtable used to store the properties
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Count">
+            <summary>
+            The number of properties in this collection
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class 
+            with serialized data.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Because this class is sealed the serialization constructor is private.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Remove(System.String)">
+            <summary>
+            Remove the entry with the specified key from this dictionary
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+            <returns>an enumerator</returns>
+            <remarks>
+            <para>
+            Returns a <see cref="T:System.Collections.IDictionaryEnumerator"/> over the contest of this collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key">the key to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key">the key to lookup in the collection</param>
+            <returns><c>true</c> if the collection contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if this collection contains a specified key.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+            <remarks>
+            <para>
+            Remove all properties from the properties collection
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key">the key</param>
+            <param name="value">the value to store for the key</param>
+            <remarks>
+            <para>
+            Store a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+            <value>
+            <c>false</c>
+            </value>
+            <remarks>
+            <para>
+            This collection is modifiable. This property always
+            returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+            <value>
+            The value for the key specified.
+            </value>
+            <remarks>
+            <para>
+            Get or set a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="T:log4net.Util.PropertyEntry">
+            <summary>
+            A class to hold the key and data for a property set in the config file
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the key and data for a property set in the config file
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertyEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Key">
+            <summary>
+            Property Key
+            </summary>
+            <value>
+            Property Key
+            </value>
+            <remarks>
+            <para>
+            Property Key.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Value">
+            <summary>
+            Property Value
+            </summary>
+            <value>
+            Property Value
+            </value>
+            <remarks>
+            <para>
+            Property Value.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ProtectCloseTextWriter">
+            <summary>
+            A <see cref="T:System.IO.TextWriter"/> that ignores the <see cref="M:log4net.Util.ProtectCloseTextWriter.Close"/> message
+            </summary>
+            <remarks>
+            <para>
+            This writer is used in special cases where it is necessary 
+            to protect a writer from being closed by a client.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <remarks>
+            <para>
+            Create a new ProtectCloseTextWriter using a writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Attach(System.IO.TextWriter)">
+            <summary>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to attach to</param>
+            <remarks>
+            <para>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Close">
+            <summary>
+            Does not close the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Does not close the underlying output writer.
+            This method does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReaderWriterLock">
+            <summary>
+            Defines a lock that supports single writers and multiple readers
+            </summary>
+            <remarks>
+            <para>
+            <c>ReaderWriterLock</c> is used to synchronize access to a resource. 
+            At any given time, it allows either concurrent read access for 
+            multiple threads, or write access for a single thread. In a 
+            situation where a resource is changed infrequently, a 
+            <c>ReaderWriterLock</c> provides better throughput than a simple 
+            one-at-a-time lock, such as <see cref="T:System.Threading.Monitor"/>.
+            </para>
+            <para>
+            If a platform does not support a <c>System.Threading.ReaderWriterLock</c> 
+            implementation then all readers and writers are serialized. Therefore 
+            the caller must not rely on multiple simultaneous readers.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReaderWriterLock"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireReaderLock">
+            <summary>
+            Acquires a reader lock
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.AcquireReaderLock"/> blocks if a different thread has the writer 
+            lock, or if at least one thread is waiting for the writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock">
+            <summary>
+            Decrements the lock count
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock"/> decrements the lock count. When the count 
+            reaches zero, the lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireWriterLock">
+            <summary>
+            Acquires the writer lock
+            </summary>
+            <remarks>
+            <para>
+            This method blocks if another thread has a reader lock or writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseWriterLock">
+            <summary>
+            Decrements the lock count on the writer lock
+            </summary>
+            <remarks>
+            <para>
+            ReleaseWriterLock decrements the writer lock count. 
+            When the count reaches zero, the writer lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReusableStringWriter">
+            <summary>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.
+            This uses a single buffer for string operations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </summary>
+            <param name="formatProvider">the format provider to use</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">
+            <summary>
+            Override Dispose to prevent closing of writer
+            </summary>
+            <param name="disposing">flag</param>
+            <remarks>
+            <para>
+            Override Dispose to prevent closing of writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">
+            <summary>
+            Reset this string writer so that it can be reused.
+            </summary>
+            <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>
+            <param name="defaultSize">the default size to make the buffer</param>
+            <remarks>
+            <para>
+            Reset this string writer so that it can be reused.
+            The internal buffers are cleared and reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemInfo">
+            <summary>
+            Utility class for system specific information.
+            </summary>
+            <remarks>
+            <para>
+            Utility class of static methods for system specific information.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Alexey Solofnenko</author>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#ctor">
+            <summary>
+            Private constructor to prevent instances.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#cctor">
+            <summary>
+            Initialize default values for private static fields.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyLocationInfo(System.Reflection.Assembly)">
+            <summary>
+            Gets the assembly location path for the specified assembly.
+            </summary>
+            <param name="myAssembly">The assembly to get the location for.</param>
+            <returns>The location of the assembly.</returns>
+            <remarks>
+            <para>
+            This method does not guarantee to return the correct path
+            to the assembly. If only tries to give an indication as to
+            where the assembly was loaded from.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyQualifiedName(System.Type)">
+            <summary>
+            Gets the fully qualified name of the <see cref="T:System.Type"/>, including 
+            the name of the assembly from which the <see cref="T:System.Type"/> was 
+            loaded.
+            </summary>
+            <param name="type">The <see cref="T:System.Type"/> to get the fully qualified name for.</param>
+            <returns>The fully qualified name for the <see cref="T:System.Type"/>.</returns>
+            <remarks>
+            <para>
+            This is equivalent to the <c>Type.AssemblyQualifiedName</c> property,
+            but this method works on the .NET Compact Framework 1.0 as well as
+            the full .NET runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyShortName(System.Reflection.Assembly)">
+            <summary>
+            Gets the short name of the <see cref="T:System.Reflection.Assembly"/>.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the name for.</param>
+            <returns>The short name of the <see cref="T:System.Reflection.Assembly"/>.</returns>
+            <remarks>
+            <para>
+            The short name of the assembly is the <see cref="P:System.Reflection.Assembly.FullName"/> 
+            without the version, culture, or public key. i.e. it is just the 
+            assembly's file name without the extension.
+            </para>
+            <para>
+            Use this rather than <c>Assembly.GetName().Name</c> because that
+            is not available on the Compact Framework.
+            </para>
+            <para>
+            Because of a FileIOPermission security demand we cannot do
+            the obvious Assembly.GetName().Name. We are allowed to get
+            the <see cref="P:System.Reflection.Assembly.FullName"/> of the assembly so we 
+            start from there and strip out just the assembly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyFileName(System.Reflection.Assembly)">
+            <summary>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the file name for.</param>
+            <returns>The file name of the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Type,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeType">A sibling type to use to load the type.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified, it will be loaded from the assembly
+            containing the specified relative type. If the type is not found in the assembly 
+            then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>		
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the
+            assembly that is directly calling this method. If the type is not found 
+            in the assembly then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Reflection.Assembly,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeAssembly">An assembly to load the type from.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the specified
+            assembly. If the type is not found in the assembly then all the loaded assemblies 
+            will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.NewGuid">
+            <summary>
+            Generate a new guid
+            </summary>
+            <returns>A new Guid</returns>
+            <remarks>
+            <para>
+            Generate a new guid
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateArgumentOutOfRangeException(System.String,System.Object,System.String)">
+            <summary>
+            Create an <see cref="T:System.ArgumentOutOfRangeException"/>
+            </summary>
+            <param name="parameterName">The name of the parameter that caused the exception</param>
+            <param name="actualValue">The value of the argument that causes this exception</param>
+            <param name="message">The message that describes the error</param>
+            <returns>the ArgumentOutOfRangeException object</returns>
+            <remarks>
+            <para>
+            Create a new instance of the <see cref="T:System.ArgumentOutOfRangeException"/> class 
+            with a specified error message, the parameter name, and the value 
+            of the argument.
+            </para>
+            <para>
+            The Compact Framework does not support the 3 parameter constructor for the
+            <see cref="T:System.ArgumentOutOfRangeException"/> type. This method provides an
+            implementation that works for all platforms.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int32@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int32"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int64@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int64"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int16@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int16"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetAppSetting(System.String)">
+            <summary>
+            Lookup an application setting
+            </summary>
+            <param name="key">the application settings key to lookup</param>
+            <returns>the value for the key, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Configuration APIs are not supported under the Compact Framework
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified local file path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            <para>
+            The path specified must be a local file path, a URI is not supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateCaseInsensitiveHashtable">
+            <summary>
+            Creates a new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity. 
+            </summary>
+            <returns>A new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity</returns>
+            <remarks>
+            <para>
+            The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.EqualsIgnoringCase(System.String,System.String)">
+            <summary>
+            Tests two strings for equality, the ignoring case.
+            </summary>
+            <remarks>
+            If the platform permits, culture information is ignored completely (ordinal comparison).
+            The aim of this method is to provide a fast comparison that deals with <c>null</c> and ignores different casing.
+            It is not supposed to deal with various, culture-specific habits.
+            Use it to compare against pure ASCII constants, like keywords etc.
+            </remarks>
+            <param name="a">The one string.</param>
+            <param name="b">The other string.</param>
+            <returns><c>true</c> if the strings are equal, <c>false</c> otherwise.</returns>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.EmptyTypes">
+            <summary>
+            Gets an empty array of types.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Type.EmptyTypes</c> field is not available on
+            the .NET Compact Framework 1.0.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.declaringType">
+            <summary>
+            The fully qualified type of the SystemInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_hostName">
+            <summary>
+            Cache the host name for the current machine
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_appFriendlyName">
+            <summary>
+            Cache the application friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_nullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_notAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_processStartTimeUtc">
+            <summary>
+            Start time for the current process.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NewLine">
+            <summary>
+            Gets the system dependent line terminator.
+            </summary>
+            <value>
+            The system dependent line terminator.
+            </value>
+            <remarks>
+            <para>
+            Gets the system dependent line terminator.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationBaseDirectory">
+            <summary>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The base directory path for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ConfigurationFileLocation">
+            <summary>
+            Gets the path to the configuration file for the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the configuration file for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            The .NET Compact Framework 1.0 does not have a concept of a configuration
+            file. For this runtime, we use the entry assembly location as the root for
+            the configuration file name.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.EntryAssemblyLocation">
+            <summary>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the entry assembly.</value>
+            <remarks>
+            <para>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.CurrentThreadId">
+            <summary>
+            Gets the ID of the current thread.
+            </summary>
+            <value>The ID of the current thread.</value>
+            <remarks>
+            <para>
+            On the .NET framework, the <c>AppDomain.GetCurrentThreadId</c> method
+            is used to obtain the thread ID for the current thread. This is the 
+            operating system ID for the thread.
+            </para>
+            <para>
+            On the .NET Compact Framework 1.0 it is not possible to get the 
+            operating system thread ID for the current thread. The native method 
+            <c>GetCurrentThreadId</c> is implemented inline in a header file
+            and cannot be called.
+            </para>
+            <para>
+            On the .NET Framework 2.0 the <c>Thread.ManagedThreadId</c> is used as this
+            gives a stable id unrelated to the operating system thread ID which may 
+            change if the runtime is using fibers.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.HostName">
+            <summary>
+            Get the host name or machine name for the current machine
+            </summary>
+            <value>
+            The hostname or machine name
+            </value>
+            <remarks>
+            <para>
+            Get the host name or machine name for the current machine
+            </para>
+            <para>
+            The host name (<see cref="M:System.Net.Dns.GetHostName"/>) or
+            the machine name (<c>Environment.MachineName</c>) for
+            the current machine, or if neither of these are available
+            then <c>NOT AVAILABLE</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationFriendlyName">
+            <summary>
+            Get this application's friendly name
+            </summary>
+            <value>
+            The friendly name of this application as a string
+            </value>
+            <remarks>
+            <para>
+            If available the name of the application is retrieved from
+            the <c>AppDomain</c> using <c>AppDomain.CurrentDomain.FriendlyName</c>.
+            </para>
+            <para>
+            Otherwise the file name of the entry assembly is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTime">
+            <summary>
+            Get the start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTimeUtc">
+            <summary>
+            Get the UTC start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the UTC time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+            <remarks>
+            <para>
+            Use this value to indicate a <c>null</c> has been encountered while
+            outputting a string representation of an item.
+            </para>
+            <para>
+            The default value is <c>(null)</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NullText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NotAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+            <remarks>
+            <para>
+            Use this value when an unsupported feature is requested.
+            </para>
+            <para>
+            The default value is <c>NOT AVAILABLE</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NotAvailableText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemStringFormat">
+            <summary>
+            Utility class that represents a format string.
+            </summary>
+            <remarks>
+            <para>
+            Utility class that represents a format string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.#ctor(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Initialise the <see cref="T:log4net.Util.SystemStringFormat"/>
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.ToString">
+            <summary>
+            Format the string and arguments
+            </summary>
+            <returns>the formatted string</returns>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Replaces the format item in a specified <see cref="T:System.String"/> with the text equivalent 
+            of the value of a corresponding <see cref="T:System.Object"/> instance in a specified array.
+            A specified parameter supplies culture-specific formatting information.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+            <returns>
+            A copy of format in which the format items have been replaced by the <see cref="T:System.String"/> 
+            equivalent of the corresponding instances of <see cref="T:System.Object"/> in args.
+            </returns>
+            <remarks>
+            <para>
+            This method does not throw exceptions. If an exception thrown while formatting the result the
+            exception and arguments are returned in the result string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormatError(System.Exception,System.String,System.Object[])">
+            <summary>
+            Process an error during StringFormat
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderArray(System.Array,System.Text.StringBuilder)">
+            <summary>
+            Dump the contents of an array into a string builder
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderObject(System.Object,System.Text.StringBuilder)">
+            <summary>
+            Dump an object to a string
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemStringFormat.declaringType">
+            <summary>
+            The fully qualified type of the SystemStringFormat class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextProperties._dictionary">
+            <summary>
+            Each thread will automatically have its instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove a property
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetKeys">
+            <summary>
+            Get the keys stored in the properties.
+            </summary>
+            <para>
+            Gets the keys stored in the properties.
+            </para>
+            <returns>a set of the defined keys</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Clear">
+            <summary>
+            Clear all properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the <c>PropertiesDictionary</c> for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this tread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.ThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.ThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.ThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameStack">
+            <summary>
+            The ThreadContextStack internal stack
+            </summary>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.#ctor(System.Collections.Stack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.Transform">
+            <summary>
+            Utility class for transforming strings.
+            </summary>
+            <remarks>
+            <para>
+            Utility class for transforming strings.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.Transform.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.Transform"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.WriteEscapedXmlString(System.Xml.XmlWriter,System.String,System.String)">
+            <summary>
+            Write a string to an <see cref="T:System.Xml.XmlWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="textData">the string to write</param>
+            <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param>
+            <remarks>
+            <para>
+            The test is escaped either using XML escape entities
+            or using CDATA sections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.MaskXmlInvalidCharacters(System.String,System.String)">
+            <summary>
+            Replace invalid XML characters in text string
+            </summary>
+            <param name="textData">the XML text input string</param>
+            <param name="mask">the string to use in place of invalid characters</param>
+            <returns>A string that does not contain invalid XML characters.</returns>
+            <remarks>
+            <para>
+            Certain Unicode code points are not allowed in the XML InfoSet, for
+            details see: <a href="http://www.w3.org/TR/REC-xml/#charsets">http://www.w3.org/TR/REC-xml/#charsets</a>.
+            </para>
+            <para>
+            This method replaces any illegal characters in the input string
+            with the mask string specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.CountSubstrings(System.String,System.String)">
+            <summary>
+            Count the number of times that the substring occurs in the text
+            </summary>
+            <param name="text">the text to search</param>
+            <param name="substring">the substring to find</param>
+            <returns>the number of times the substring occurs in the text</returns>
+            <remarks>
+            <para>
+            The substring is assumed to be non repeating within itself.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.Transform.INVALIDCHARS">
+            <summary>
+            Characters illegal in XML 1.0
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext">
+            <summary>
+            Impersonate a Windows Account
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.SecurityContext"/> impersonates a Windows account.
+            </para>
+            <para>
+            How the impersonation is done depends on the value of <see cref="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)"/>.
+            This allows the context to either impersonate a set of user credentials specified 
+            using username, domain name and password or to revert to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.ActivateOptions">
+            <summary>
+            Initialize the SecurityContext based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The security context will try to Logon the specified user account and
+            capture a primary token for impersonation.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, 
+            <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> or <see cref="P:log4net.Util.WindowsSecurityContext.Password"/> properties were not specified.</exception>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.
+            </summary>
+            <param name="state">caller provided state</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> instance that will revoke the impersonation of this SecurityContext
+            </returns>
+            <remarks>
+            <para>
+            Depending on the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property either
+            impersonate a user using credentials supplied or revert 
+            to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.LogonUser(System.String,System.String,System.String)">
+            <summary>
+            Create a <see cref="T:System.Security.Principal.WindowsIdentity"/> given the userName, domainName and password.
+            </summary>
+            <param name="userName">the user name</param>
+            <param name="domainName">the domain name</param>
+            <param name="password">the password</param>
+            <returns>the <see cref="T:System.Security.Principal.WindowsIdentity"/> for the account specified</returns>
+            <remarks>
+            <para>
+            Uses the Windows API call LogonUser to get a principal token for the account. This
+            token is used to initialize the WindowsIdentity.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Credentials">
+            <summary>
+            Gets or sets the impersonation mode for this security context
+            </summary>
+            <value>
+            The impersonation mode for this security context
+            </value>
+            <remarks>
+            <para>
+            Impersonate either a user with user credentials or
+            revert this thread to the credentials of the process.
+            The value is one of the <see cref="T:log4net.Util.WindowsSecurityContext.ImpersonationMode"/>
+            enum.
+            </para>
+            <para>
+            The default value is <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            the user's credentials are established using the
+            <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.Password"/>
+            values.
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process"/>
+            no other properties need to be set. If the calling thread is 
+            impersonating then it will be reverted back to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.UserName">
+            <summary>
+            Gets or sets the Windows username for this security context
+            </summary>
+            <value>
+            The Windows username for this security context
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.DomainName">
+            <summary>
+            Gets or sets the Windows domain name for this security context
+            </summary>
+            <value>
+            The Windows domain name for this security context
+            </value>
+            <remarks>
+            <para>
+            The default value for <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> is the local machine name
+            taken from the <see cref="P:System.Environment.MachineName"/> property.
+            </para>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Password">
+            <summary>
+            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.
+            </summary>
+            <value>
+            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.
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.ImpersonationMode">
+            <summary>
+            The impersonation modes for the <see cref="T:log4net.Util.WindowsSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            See the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property for
+            details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User">
+            <summary>
+            Impersonate a user using the credentials supplied
+            </summary>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process">
+            <summary>
+            Revert this the thread to the credentials of the process
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext">
+            <summary>
+            Adds <see cref="T:System.IDisposable"/> to <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Helper class to expose the <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            through the <see cref="T:System.IDisposable"/> interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.#ctor(System.Security.Principal.WindowsImpersonationContext)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="impersonationContext">the impersonation context being wrapped</param>
+            <remarks>
+            <para>
+            Constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.Dispose">
+            <summary>
+            Revert the impersonation
+            </summary>
+            <remarks>
+            <para>
+            Revert the impersonation
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.GlobalContext">
+            <summary>
+            The log4net Global Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>GlobalContext</c> provides a location for global debugging 
+            information to be stored.
+            </para>
+            <para>
+            The global context has a properties map and these properties can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputing these properties.
+            </para>
+            <para>
+            By default the <c>log4net:HostName</c> property is set to the name of 
+            the current machine.
+            </para>
+            </remarks>
+            <example>
+            <code lang="C#">
+            GlobalContext.Properties["hostname"] = Environment.MachineName;
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.GlobalContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="F:log4net.GlobalContext.s_properties">
+            <summary>
+            The global context properties instance
+            </summary>
+        </member>
+        <member name="P:log4net.GlobalContext.Properties">
+            <summary>
+            The global properties map.
+            </summary>
+            <value>
+            The global properties map.
+            </value>
+            <remarks>
+            <para>
+            The global properties map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.AssemblyInfo">
+            <summary>
+            Provides information about the environment the assembly has
+            been built for.
+            </summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.Version">
+            <summary>Version of the assembly</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFrameworkVersion">
+            <summary>Version of the framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFramework">
+            <summary>Type of framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.ClientProfile">
+            <summary>Does it target a client profile?</summary>
+        </member>
+        <member name="P:log4net.AssemblyInfo.Info">
+            <summary>
+            Identifies the version and target for this assembly.
+            </summary>
+        </member>
+        <member name="T:log4net.LogicalThreadContext">
+            <summary>
+            The log4net Logical Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> provides a location for <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> specific debugging 
+            information to be stored.
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> or <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The Logical Thread Context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Logical Thread Context provides a diagnostic context for the current call context. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Logical Thread Context is managed on a per <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> basis.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            LogicalThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a LogicalThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.LogicalThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> 
+            or <see cref="T:log4net.GlobalContext"/> properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The logical thread stacks.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.LogManager">
+            <summary>
+            This class is used by client applications to request logger instances.
+            </summary>
+            <remarks>
+            <para>
+            This class has static methods that are used by a client to request
+            a logger instance. The <see cref="M:GetLogger(string)"/> method is 
+            used to retrieve a logger.
+            </para>
+            <para>
+            See the <see cref="T:log4net.ILog"/> interface for more details.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <seealso cref="T:log4net.ILog"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.LogManager.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.LogManager"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String)">
+            <overloads>Returns the named logger if it exists.</overloads>
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the default repository) then it
+            returns a reference to the logger, otherwise it returns <c>null</c>.
+            </para>
+            </remarks>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>The logger found, or <c>null</c> if no logger could be found.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers">
+            <overloads>Get the currently defined loggers.</overloads>
+            <summary>
+            Returns all the currently defined loggers in the default repository.
+            </summary>
+            <remarks>
+            <para>The root logger is <b>not</b> included in the returned array.</para>
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String)">
+            <overloads>Get or create a logger.</overloads>
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the logger doesn't exist in the specified 
+            repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the repository for the specified assembly) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger, or <c>null</c> if the logger doesn't exist in the specified
+            assembly's repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Get the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository">
+            <overloads>Shutdown a logger repository.</overloads>
+            <summary>
+            Shuts down the default repository.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            default repository.
+            </para>
+            <para>Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repository">The repository to shutdown.</param>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration">
+            <overloads>Reset the configuration of a repository</overloads>
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repository">The repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository">
+            <overloads>Get the logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository">
+            <overloads>Get a logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Type)">
+            <overloads>Create a domain</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Type)">
+            <overloads>Create a logger repository.</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetAllRepositories">
+            <summary>
+            Gets the list of currently defined repositories.
+            </summary>
+            <remarks>
+            <para>
+            Get an array of all the <see cref="T:log4net.Repository.ILoggerRepository"/> objects that have been created.
+            </para>
+            </remarks>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Flush(System.Int32)">
+            <summary>
+            Flushes logging events buffered in all configured appenders in the default repository.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLogger(log4net.Core.ILogger)">
+            <summary>
+            Looks up the wrapper object for the logger specified.
+            </summary>
+            <param name="logger">The logger to get the wrapper for.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLoggers(log4net.Core.ILogger[])">
+            <summary>
+            Looks up the wrapper objects for the loggers specified.
+            </summary>
+            <param name="loggers">The loggers to get the wrappers for.</param>
+            <returns>The wrapper objects for the loggers specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapperCreationHandler(log4net.Core.ILogger)">
+            <summary>
+            Create the <see cref="T:log4net.Core.ILoggerWrapper"/> objects used by
+            this manager.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="F:log4net.LogManager.s_wrapperMap">
+            <summary>
+            The wrapper map to use to hold the <see cref="T:log4net.Core.LogImpl"/> objects.
+            </summary>
+        </member>
+        <member name="T:log4net.MDC">
+            <summary>
+            Implementation of Mapped Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is
+            based on a map instead of a stack. It provides <i>mapped
+            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or
+            MDC in short, is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The MDC is managed on a per thread basis.
+            </para>
+            </remarks>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.MDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.MDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Get(System.String)">
+            <summary>
+            Gets the context value identified by the <paramref name="key"/> parameter.
+            </summary>
+            <param name="key">The key to lookup in the MDC.</param>
+            <returns>The string value held for the key, or a <c>null</c> reference if no corresponding value is found.</returns>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            If the <paramref name="key"/> parameter does not look up to a
+            previously defined context then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Set(System.String,System.String)">
+            <summary>
+            Add an entry to the MDC
+            </summary>
+            <param name="key">The key to store the value under.</param>
+            <param name="value">The value to store.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Puts a context value (the <paramref name="value"/> parameter) as identified
+            with the <paramref name="key"/> parameter into the current thread's
+            context map.
+            </para>
+            <para>
+            If a value is already defined for the <paramref name="key"/>
+            specified then the value will be replaced. If the <paramref name="value"/> 
+            is specified as <c>null</c> then the key value mapping will be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Remove(System.String)">
+            <summary>
+            Removes the key value mapping for the key specified.
+            </summary>
+            <param name="key">The key to remove.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove the specified entry from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Clear">
+            <summary>
+            Clear all entries in the MDC
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove all the entries from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.NDC">
+            <summary>
+            Implementation of Nested Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            A Nested Diagnostic Context, or NDC in short, is an instrument
+            to distinguish interleaved log output from different sources. Log
+            output is typically interleaved when a server handles multiple
+            clients near-simultaneously.
+            </para>
+            <para>
+            Interleaved log output can still be meaningful if each log entry
+            from different contexts had a distinctive stamp. This is where NDCs
+            come into play.
+            </para>
+            <para>
+            Note that NDCs are managed on a per thread basis. The NDC class
+            is made up of static methods that operate on the context of the
+            calling thread.
+            </para>
+            </remarks>
+            <example>How to push a message into the context
+            <code lang="C#">
+            using(NDC.Push("my context message"))
+            {
+            	... all log calls will have 'my context message' included ...
+            
+            } // at the end of the using block the message is automatically removed 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.NDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.NDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Clear">
+            <summary>
+            Clears all the contextual information held on the current thread.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Clears the stack of NDC data held on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.CloneStack">
+            <summary>
+            Creates a clone of the stack of context information.
+            </summary>
+            <returns>A clone of the context info for this thread.</returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The results of this method can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> 
+            method to allow child threads to inherit the context of their 
+            parent thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">
+            <summary>
+            Inherits the contextual information from another thread.
+            </summary>
+            <param name="stack">The context stack to inherit.</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This thread will use the context information from the stack
+            supplied. This can be used to initialize child threads with
+            the same contextual information as their parent threads. These
+            contexts will <b>NOT</b> be shared. Any further contexts that
+            are pushed onto the stack will not be visible to the other.
+            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to
+            this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Pop">
+            <summary>
+            Removes the top context from the stack.
+            </summary>
+            <returns>
+            The message in the context that was removed from the top 
+            of the stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Remove the top context from the stack, and return
+            it to the caller. If the stack is empty then an
+            empty string (not <c>null</c>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Push(System.String)">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.NDC.Push("NDC_Message"))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.PushFormat(System.String,System.Object[])">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="messageFormat">The new context message string format.</param>
+            <param name="args">Arguments to be passed into messageFormat.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            var someValue = "ExampleContext"
+            using(log4net.NDC.PushFormat("NDC_Message {0}", someValue))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.Remove">
+            <summary>
+            Removes the context information for this thread. It is
+            not required to call this method.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This method is not implemented.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">
+            <summary>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            </summary>
+            <param name="maxDepth">The maximum depth of the stack</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            This may truncate the head of the stack. This only affects the 
+            stack in the current thread. Also it does not prevent it from
+            growing, it only sets the maximum depth at the time of the
+            call. This can be used to return to a known context depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.NDC.Depth">
+            <summary>
+            Gets the current context depth.
+            </summary>
+            <value>The current context depth.</value>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The number of context values pushed onto the context stack.
+            </para>
+            <para>
+            Used to record the current depth of the context. This can then 
+            be restored using the <see cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/> method.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/>
+        </member>
+        <member name="T:log4net.ThreadContext">
+            <summary>
+            The log4net Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> provides a location for thread specific debugging 
+            information to be stored.
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            The thread context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Thread Context provides a diagnostic context for the current thread. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Thread Context is managed on a per thread basis.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            ThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a ThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(ThreadContext.Stacks["NDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a ThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.ThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.ThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.ThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.ThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The thread local stacks.
+            </para>
+            </remarks>
+        </member>
+    </members>
+</doc>
diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-full/log4net.dll b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-full/log4net.dll
new file mode 100644
index 0000000000000000000000000000000000000000..a4af9d6d9d5fde81b95148df0b18ae89b1e52781
GIT binary patch
literal 275968
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

literal 0
HcmV?d00001

diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-full/log4net.xml b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-full/log4net.xml
new file mode 100644
index 000000000..18f17674e
--- /dev/null
+++ b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net40-full/log4net.xml
@@ -0,0 +1,32464 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>log4net</name>
+    </assembly>
+    <members>
+        <member name="T:log4net.Appender.AdoNetAppender">
+            <summary>
+            Appender that logs to a database.
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
+            database. The appender can be configured to specify the connection 
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
+            property. For more information on database connection strings for
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
+            </para>
+            <para>
+            Records are written into the database either using a prepared
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
+            procedure.
+            </para>
+            <para>
+            The prepared statement text or the name of the stored procedure
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
+            </para>
+            <para>
+            The prepared statement or stored procedure can take a number
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
+            type may be subclassed if required to provide database specific
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
+            the parameter name, database type, size, and how the value should
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
+            </para>
+            </remarks>
+            <example>
+            An example of a SQL Server table that could be logged to:
+            <code lang="SQL">
+            CREATE TABLE [dbo].[Log] ( 
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,
+              [Date] [datetime] NOT NULL ,
+              [Thread] [varchar] (255) NOT NULL ,
+              [Level] [varchar] (20) NOT NULL ,
+              [Logger] [varchar] (255) NOT NULL ,
+              [Message] [varchar] (4000) NOT NULL 
+            ) ON [PRIMARY]
+            </code>
+            </example>
+            <example>
+            An example configuration to log to the above table:
+            <code lang="XML" escaped="true">
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
+              <parameter>
+                <parameterName value="@log_date"/>
+                <dbType value="DateTime"/>
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@thread"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@log_level"/>
+                <dbType value="String"/>
+                <size value="50"/>
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@logger"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@message"/>
+                <dbType value="String"/>
+                <size value="4000"/>
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>
+              </parameter>
+            </appender>
+            </code>
+            </example>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Lance Nehring</author>
+        </member>
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
+            buffers events in a fixed size buffer.
+            </summary>
+            <remarks>
+            <para>
+            This base class should be used by appenders that need to buffer a 
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            buffers events and then submits the entire contents of the buffer to 
+            the underlying database in one go.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:SendBuffer(LoggingEvent[])"/>
+            method to deliver the buffered events.
+            </para>
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
+            buffer of events. The size of the buffer is set using 
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
+            </para>
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
+            triggers, then the current buffer is sent immediately 
+            (see <see cref="M:SendBuffer(LoggingEvent[])"/>). Otherwise the event 
+            is stored in the buffer. For example, an evaluator can be used to 
+            deliver the events immediately when an ERROR event arrives.
+            </para>
+            <para>
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
+            By default the appender is NOT lossy. When the buffer is full all 
+            the buffered events are sent with <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
+            buffer will not be sent when it is full, and new events arriving 
+            in the appender will overwrite the oldest event in the buffer. 
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
+            triggers. This can be useful behavior when you need to know about 
+            ERROR events but not about events with a lower level, configure an 
+            evaluator that will trigger when an ERROR event arrives, the whole 
+            buffer will be sent which gives a history of events leading up to
+            the ERROR event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.AppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
+            </summary>
+            <remarks>
+            <para>
+            This class provides the code for common functionality, such 
+            as support for threshold filtering and support for general filters.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.IAppender">
+            <summary>
+            Implement this interface for your own strategies for printing log statements.
+            </summary>
+            <remarks>
+            <para>
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
+            class which provides a default implementation of this interface.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.IAppender.Close">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logging event in Appender specific way.
+            </summary>
+            <param name="loggingEvent">The event to log</param>
+            <remarks>
+            <para>
+            This method is called to log a message into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.IAppender.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>The name uniquely identifies the appender.</para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IBulkAppender">
+            <summary>
+            Interface for appenders that support bulk logging.
+            </summary>
+            <remarks>
+            <para>
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
+            should only implement this interface if they can bulk log efficiently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Log the array of logging events in Appender specific way.
+            </summary>
+            <param name="loggingEvents">The events to log</param>
+            <remarks>
+            <para>
+            This method is called to log an array of events into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IOptionHandler">
+            <summary>
+            Interface used to delay activate a configured object.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
+            must be called by the container after its all the configured properties have been set 
+            and before the component can be used.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
+            <summary>
+            Activate the options that were previously set with calls to properties.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then this method must be called
+            after its properties have been set before the component can be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IFlushable">
+            <summary>
+            Interface that can be implemented by Appenders that buffer logging data and expose a <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.IFlushable.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            Appenders that implement the <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method must do so in a thread-safe manner: it can be called concurrently with
+            the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            <para>
+            Typically this is done by locking on the Appender instance, e.g.:
+            <code>
+            <![CDATA[
+            public bool Flush(int millisecondsTimeout)
+            {
+                lock(this)
+                {
+                    // Flush buffered logging data
+                    ...
+                }
+            }
+            ]]>
+            </code>
+            </para>
+            <para>
+            The <paramref name="millisecondsTimeout"/> parameter is only relevant for appenders that process logging events asynchronously,
+            such as <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            </remarks>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>Empty default constructor</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
+            <summary>
+            Finalizes this appender by calling the implementation's 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
+            </summary>
+            <remarks>
+            <para>
+            If this appender has not been closed then the <c>Finalize</c> method
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">
+            <summary>
+            Closes the appender and release resources.
+            </summary>
+            <remarks>
+            <para>
+            Release any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            <para>
+            This method cannot be overridden by subclasses. This method 
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
+            method which must be overridden in the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent)"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>
+            will be passed to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent[])"/> method.
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent[])"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvents"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvents"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>
+            will be passed to the <see cref="M:Append(LoggingEvent[])"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if the logging event should we output by this appender
+            </summary>
+            <param name="loggingEvent">the event to test</param>
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
+            <remarks>
+            <para>
+            This method checks the logging event against the threshold level set
+            on this appender and also against the filters specified on this
+            appender.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
+            <summary>
+            Adds a filter to the end of the filter chain.
+            </summary>
+            <param name="filter">the filter to add to this appender</param>
+            <remarks>
+            <para>
+            The Filters are organized in a linked list.
+            </para>
+            <para>
+            Setting this property causes the new filter to be pushed onto the 
+            back of the filter chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
+            <summary>
+            Clears the filter list for this appender.
+            </summary>
+            <remarks>
+            <para>
+            Clears the filter list for this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
+            <summary>
+            Checks if the message level is below this appender's threshold.
+            </summary>
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
+            <remarks>
+            <para>
+            If there is no threshold set, then the return value is always <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
+            requirements of this appender.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
+            <summary>
+            Is called when the appender is closed. Derived classes should override 
+            this method if resources need to be released.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
+            to perform actual logging.
+            </summary>
+            <param name="loggingEvent">The event to append.</param>
+            <remarks>
+            <para>
+            A subclass must implement this method to perform
+            logging of the <paramref name="loggingEvent"/>.
+            </para>
+            <para>This method will be called by <see cref="M:DoAppend(LoggingEvent)"/>
+            if all the conditions listed for that method are met.
+            </para>
+            <para>
+            To restrict the logging of events in the appender
+            override the <see cref="M:PreAppendCheck()"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append a bulk array of logging events.
+            </summary>
+            <param name="loggingEvents">the array of logging events</param>
+            <remarks>
+            <para>
+            This base class implementation calls the <see cref="M:Append(LoggingEvent)"/>
+            method for each element in the bulk array.
+            </para>
+            <para>
+            A sub class that can better process a bulk array of events should
+            override this method in addition to <see cref="M:Append(LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
+            <summary>
+            Called before <see cref="M:Append(LoggingEvent)"/> as a precondition.
+            </summary>
+            <remarks>
+            <para>
+            This method is called by <see cref="M:DoAppend(LoggingEvent)"/>
+            before the call to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            This method can be overridden in a subclass to extend the checks 
+            made before the event is passed to the <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            A subclass should ensure that they delegate this call to
+            this base class if it is overridden.
+            </para>
+            </remarks>
+            <returns><c>true</c> if the call to <see cref="M:Append(LoggingEvent)"/> should proceed.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <returns>The event rendered as a string.</returns>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Where possible use the alternative version of this method
+            <see cref="M:RenderLoggingEvent(TextWriter,LoggingEvent)"/>.
+            That method streams the rendering onto an existing Writer
+            which can give better performance if the caller already has
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>
+            where possible. If, however, the caller needs to render the event
+            to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does
+            provide an efficient mechanism for doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            This implementation doesn't flush anything and always returns true
+            </remarks>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
+            <summary>
+            The layout of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
+            <summary>
+            The name of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
+            <summary>
+            The level threshold of this appender.
+            </summary>
+            <remarks>
+            <para>
+            There is no level threshold filtering by default.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
+            <summary>
+            It is assumed and enforced that errorHandler is never null.
+            </summary>
+            <remarks>
+            <para>
+            It is assumed and enforced that errorHandler is never null.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
+            <summary>
+            The first filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>null</c> initially.
+            </para>
+            <para>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
+            <summary>
+            The last filter in the filter chain.
+            </summary>
+            <remarks>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
+            <summary>
+            Flag indicating if this appender is closed.
+            </summary>
+            <remarks>
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
+            <summary>
+            The guard prevents an appender from repeatedly calling its own DoAppend method
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
+            <summary>
+            StringWriter used to render events
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.declaringType">
+            <summary>
+            The fully qualified type of the AppenderSkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
+            <summary>
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
+            </summary>
+            <value>
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
+            </value>
+            <remarks>
+            <para>
+            All log events with lower level than the threshold level are ignored 
+            by the appender.
+            </para>
+            <para>
+            In configuration files this option is specified by setting the
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
+            string, such as "DEBUG", "INFO" and so on.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </summary>
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
+            <summary>
+            The filter chain.
+            </summary>
+            <value>The head of the filter chain filter chain.</value>
+            <remarks>
+            <para>
+            Returns the head Filter. The Filters are organized in a linked list
+            and so all Filters on this Appender are available through the result.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
+            </summary>
+            <value>The layout of the appender.</value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>
+            The name uniquely identifies the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
+            <summary>
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <remarks>
+            <para>
+            In the rather exceptional case, where the appender 
+            implementation admits a layout but can also work without it, 
+            then the appender should return <c>true</c>.
+            </para>
+            <para>
+            This default implementation always returns <c>false</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
+            <summary>
+            The default buffer size.
+            </summary>
+            <remarks>
+            The default size of the cyclic buffer used to store events.
+            This is set to 512 by default.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <param name="eventMustBeFixed">the events passed through this appender must be
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
+            <remarks>
+            <para>
+            Protected constructor to allow subclassing.
+            </para>
+            <para>
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass
+            expects the events delivered to be fixed even if the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <remarks>
+            <para>
+            Flushes any events that have been buffered.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will NOT be flushed to the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
+            <remarks>
+            <para>
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
+            In this case the contents of the buffer will be tested against the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
+            events will be discarded.
+            </para>
+            <para>
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
+            be emptied by calling this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
+            <summary>
+            Close this appender instance.
+            </summary>
+            <remarks>
+            <para>
+            Close this appender instance. If this appender is marked
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
+            the buffer must be sent when the appender is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
+            </para>
+            <para>
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
+            method) if one of the following conditions is met:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>The cyclic buffer is full and this appender is
+            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
+            	</item>
+            	<item>
+            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
+            		it is triggered for the <paramref name="loggingEvent"/>
+            		specified.</description>
+            	</item>
+            </list>
+            <para>
+            Before the event is stored in the buffer it is fixed
+            (see <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/>) to ensure that
+            any data referenced by the event will be valid when the buffer
+            is processed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
+            <summary>
+            Sends the contents of the buffer.
+            </summary>
+            <param name="firstLoggingEvent">The first logging event.</param>
+            <param name="buffer">The buffer containing the events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override this method to process the buffered events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
+            <summary>
+            The size of the cyclic buffer used to hold the logging events.
+            </summary>
+            <remarks>
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
+            <summary>
+            The cyclic buffer used to store the logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
+            <summary>
+            The triggering event evaluator that causes the buffer to be sent immediately.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event causes the entire
+            buffer to be sent immediately. This field can be <c>null</c>, which 
+            indicates that event triggering is not to be done. The evaluator
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
+            <summary>
+            Indicates if the appender should overwrite events in the cyclic buffer 
+            when it becomes full, or if the buffer should be flushed when the 
+            buffer is full.
+            </summary>
+            <remarks>
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
+            be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
+            <summary>
+            The triggering event evaluator filters discarded events.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event that is discarded should
+            really be discarded or if it should be sent to the appenders. 
+            This field can be <c>null</c>, which indicates that all discarded events will
+            be discarded. 
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
+            <summary>
+            The events delivered to the subclass must be fixed.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
+            <summary>
+            Gets or sets a value that indicates whether the appender is lossy.
+            </summary>
+            <value>
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            This appender uses a buffer to store logging events before 
+            delivering them. A triggering event causes the whole buffer
+            to be send to the remote sink. If the buffer overruns before
+            a triggering event then logging events could be lost. Set
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
+            from being lost.
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
+            <summary>
+            Gets or sets the size of the cyclic buffer used to hold the 
+            logging events.
+            </summary>
+            <value>
+            The size of the cyclic buffer used to hold the logging events.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
+            representing the maximum number of logging events to collect in 
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
+            oldest events are deleted as new events are added to the
+            buffer. By default the size of the cyclic buffer is 512 events.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
+            or equal to 1 then no buffering will occur. The logging event
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
+            be buffered.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
+            buffer to be sent immediately.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
+            sent immediately.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is appended to this 
+            appender. If the evaluator triggers then the current buffer will 
+            immediately be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
+            <summary>
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </summary>
+            <value>
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is discarded from this 
+            appender. If the evaluator triggers then the current buffer will immediately 
+            be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating if only part of the logging event data
+            should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the
+            event data to be fixed and serialized. This will improve performance.
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
+            <summary>
+            Gets or sets a the fields that will be fixed in the event
+            </summary>
+            <value>
+            The event fields that will be fixed before the event is buffered
+            </value>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
+            <summary> 
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
+            </summary>
+            <remarks>
+            Public default constructor to initialize a new instance of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
+            <summary>
+            Override the parent method to close the database
+            </summary>
+            <remarks>
+            <para>
+            Closes the database command and database connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Inserts the events into the database.
+            </summary>
+            <param name="events">The events to insert into the database.</param>
+            <remarks>
+            <para>
+            Insert all the events specified in the <paramref name="events"/>
+            array into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
+            <summary>
+            Adds a parameter to the command.
+            </summary>
+            <param name="parameter">The parameter to add to the command.</param>
+            <remarks>
+            <para>
+            Adds a parameter to the ordered list of command parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
+            <summary>
+            Writes the events to the database using the transaction specified.
+            </summary>
+            <param name="dbTran">The transaction that the events will be executed under.</param>
+            <param name="events">The array of events to insert into the database.</param>
+            <remarks>
+            <para>
+            The transaction argument can be <c>null</c> if the appender has been
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
+            property for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
+            <summary>
+            Formats the log message into database statement text.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            This method can be overridden by subclasses to provide 
+            more control over the format of the database statement.
+            </remarks>
+            <returns>
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.CreateConnection(System.Type,System.String)">
+            <summary>
+            Creates an <see cref="T:System.Data.IDbConnection"/> instance used to connect to the database.
+            </summary>
+            <remarks>
+            This method is called whenever a new IDbConnection is needed (i.e. when a reconnect is necessary).
+            </remarks>
+            <param name="connectionType">The <see cref="T:System.Type"/> of the <see cref="T:System.Data.IDbConnection"/> object.</param>
+            <param name="connectionString">The connectionString output from the ResolveConnectionString method.</param>
+            <returns>An <see cref="T:System.Data.IDbConnection"/> instance with a valid connection string.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionString(System.String@)">
+            <summary>
+            Resolves the connection string from the ConnectionString, ConnectionStringName, or AppSettingsKey
+            property.
+            </summary>
+            <remarks>
+            ConnectiongStringName is only supported on .NET 2.0 and higher.
+            </remarks>
+            <param name="connectionStringContext">Additional information describing the connection string.</param>
+            <returns>A connection string used to connect to the database.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
+            <summary>
+            Retrieves the class type of the ADO.NET provider.
+            </summary>
+            <remarks>
+            <para>
+            Gets the Type of the ADO.NET provider to use to connect to the
+            database. This method resolves the type specified in the 
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
+            </para>
+            <para>
+            Subclasses can override this method to return a different type
+            if necessary.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
+            <summary>
+            Connects to the database.
+            </summary>		
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.DiposeConnection">
+            <summary>
+            Cleanup the existing connection.
+            </summary>
+            <remarks>
+            Calls the IDbConnection's <see cref="M:System.Data.IDbConnection.Close"/> method.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
+            <summary>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </summary>
+            <remarks>
+            <para>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
+            <summary>
+            The <see cref="T:System.Data.IDbConnection"/> that will be used
+            to insert logging events into a database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
+            <summary>
+            Database connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_appSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
+            <summary>
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
+            <summary>
+            The text of the command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
+            <summary>
+            The command type.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
+            <summary>
+            Indicates whether to reconnect when a connection is lost.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.declaringType">
+            <summary>
+            The fully qualified type of the AdoNetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
+            <summary>
+            Gets or sets the database connection string that is used to connect to 
+            the database.
+            </summary>
+            <value>
+            The database connection string used to connect to the database.
+            </value>
+            <remarks>
+            <para>
+            The connections string is specific to the connection type.
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
+            </para>
+            </remarks>
+            <example>Connection string for MS Access via ODBC:
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
+            </example>
+            <example>Another connection string for MS Access via ODBC:
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
+            </example>
+            <example>Connection string for MS Access via OLE DB:
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.AppSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+            <remarks>
+            This property requires at least .NET 2.0.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
+            <summary>
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
+            that should be created.
+            </summary>
+            <value>
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
+            </value>
+            <remarks>
+            <para>
+            The type name of the ADO.NET provider to use.
+            </para>
+            <para>
+            The default is to use the OLE DB provider.
+            </para>
+            </remarks>
+            <example>Use the OLE DB Provider. This is the default value.
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the MS SQL Server Provider. 
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the ODBC Provider. 
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>ODBC .NET Data Provider</b>.
+            </example>
+            <example>Use the Oracle Provider. 
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>.NET Managed Provider for Oracle</b>.
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
+            <summary>
+            Gets or sets the command text that is used to insert logging events
+            into the database.
+            </summary>
+            <value>
+            The command text used to insert logging events into the database.
+            </value>
+            <remarks>
+            <para>
+            Either the text of the prepared statement or the
+            name of the stored procedure to execute to write into
+            the database.
+            </para>
+            <para>
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
+            this text is a prepared statement or a stored procedure.
+            </para>
+            <para>
+            If this property is not set, the command text is retrieved by invoking
+            <see cref="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
+            <summary>
+            Gets or sets the command type to execute.
+            </summary>
+            <value>
+            The command type to execute.
+            </value>
+            <remarks>
+            <para>
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
+            to execute.
+            </para>
+            <para>
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
+            <summary>
+            Should transactions be used to insert logging events in the database.
+            </summary>
+            <value>
+            <c>true</c> if transactions should be used to insert logging events in
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a value that indicates whether transactions should be used
+            to insert logging events in the database.
+            </para>
+            <para>
+            When set a single transaction will be used to insert the buffered events
+            into the database. Otherwise each event will be inserted without using
+            an explicit transaction.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
+            <summary>
+            Should this appender try to reconnect to the database on error.
+            </summary>
+            <value>
+            <c>true</c> if the appender should try to reconnect to the database after an
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
+            i.e. not to try to reconnect.
+            </value>
+            <remarks>
+            <para>
+            The default behaviour is for the appender not to try to reconnect to the
+            database if an error occurs. Subsequent logging events are discarded.
+            </para>
+            <para>
+            To force the appender to attempt to reconnect to the database set this
+            property to <c>true</c>.
+            </para>
+            <note>
+            When the appender attempts to connect to the database there may be a
+            delay of up to the connection timeout specified in the connection string.
+            This delay will block the calling application's thread. 
+            Until the connection can be reestablished this potential delay may occur multiple times.
+            </note>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Data.IDbConnection"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">
+            <summary>
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            This class provides the basic database parameter properties
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
+            </para>
+            <para>This type can be subclassed to provide database specific
+            functionality. The two methods that are called externally are
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.
+            </summary>
+            <remarks>
+            Default constructor for the AdoNetAppenderParameter class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">
+            <summary>
+            Prepare the specified database command object.
+            </summary>
+            <param name="command">The command to prepare.</param>
+            <remarks>
+            <para>
+            Prepares the database command object by adding
+            this parameter to its collection of parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the logging event and set the parameter value in the command.
+            </summary>
+            <param name="command">The command containing the parameter.</param>
+            <param name="loggingEvent">The event to be rendered.</param>
+            <remarks>
+            <para>
+            Renders the logging event using this parameters layout
+            object. Sets the value of the parameter on the command object.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">
+            <summary>
+            The name of this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">
+            <summary>
+            The database type for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">
+            <summary>
+            Flag to infer type rather than use the DbType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">
+            <summary>
+            The precision for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">
+            <summary>
+            The scale for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">
+            <summary>
+            The size for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">
+            <summary>
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the
+            logging event into an object for this parameter.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">
+            <summary>
+            Gets or sets the name of this parameter.
+            </summary>
+            <value>
+            The name of this parameter.
+            </value>
+            <remarks>
+            <para>
+            The name of this parameter. The parameter name
+            must match up to a named parameter to the SQL stored procedure
+            or prepared statement.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">
+            <summary>
+            Gets or sets the database type for this parameter.
+            </summary>
+            <value>
+            The database type for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The database type for this parameter. This property should
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the type from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">
+            <summary>
+            Gets or sets the precision for this parameter.
+            </summary>
+            <value>
+            The precision for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum number of digits used to represent the Value.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the precision from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">
+            <summary>
+            Gets or sets the scale for this parameter.
+            </summary>
+            <value>
+            The scale for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The number of decimal places to which Value is resolved.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the scale from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">
+            <summary>
+            Gets or sets the size for this parameter.
+            </summary>
+            <value>
+            The size for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum size, in bytes, of the data within the column.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the size from the value.
+            </para>
+            <para>
+            For BLOB data types like VARCHAR(max) it may be impossible to infer the value automatically, use -1 as the size in this case.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to 
+            render the logging event into an object for this 
+            parameter.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the
+            logging event into an object for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this
+            parameter.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>
+            for use in the property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">
+            <summary>
+            Appends logging events to the terminal using ANSI color escape sequences.
+            </summary>
+            <remarks>
+            <para>
+            AnsiColorTerminalAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific level of message to be set.
+            </para>
+            <note>
+            This appender expects the terminal to understand the VT100 control set 
+            in order to interpret the color codes. If the terminal or console does not
+            understand the control codes the behavior is not defined.
+            </note>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            <para>
+            When configuring the ANSI colored terminal appender, a mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red"/>
+                <attributes value="Bright,Underscore"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            </list>
+            These color values cannot be combined together to make new colors.
+            </para>
+            <para>
+            The attributes can be any combination of the following:
+            <list type="bullet">
+            <item><term>Bright</term><description>foreground is brighter</description></item>
+            <item><term>Dim</term><description>foreground is dimmer</description></item>
+            <item><term>Underscore</term><description>message is underlined</description></item>
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>
+            <item><term>Hidden</term><description>output is hidden</description></item>
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>
+            </list>
+            While any of these attributes may be combined together not all combinations
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes
+            no sense.
+            </para>
+            </remarks>
+            <author>Patrick Wagstrom</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">
+            <summary>
+            Ansi code to reset terminal
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colours
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">
+            <summary>
+            The enum of possible display attributes
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the ANSI color attributes.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">
+            <summary>
+            text is bright
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">
+            <summary>
+            text is dim
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">
+            <summary>
+            text is underlined
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">
+            <summary>
+            text is blinking
+            </summary>
+            <remarks>
+            Not all terminals support this attribute
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">
+            <summary>
+            text and background colors are reversed
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">
+            <summary>
+            text is hidden
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">
+            <summary>
+            text is displayed with a strikethrough
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Light">
+            <summary>
+            text color is light
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">
+            <summary>
+            The enum of possible foreground or background color values for 
+            use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The output can be in one for the following ANSI colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">
+            <summary>
+            color is black
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">
+            <summary>
+            color is magenta
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMappingEntry">
+            <summary>
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract base class for types that are stored in the
+            <see cref="T:log4net.Util.LevelMapping"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">
+            <summary>
+            Default protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Default protected constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
+            <summary>
+            Initialize any options defined on this entry
+            </summary>
+            <remarks>
+            <para>
+            Should be overridden by any classes that need to initialise based on their options
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LevelMappingEntry.Level">
+            <summary>
+            The level that is the key for this mapping 
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping 
+            </value>
+            <remarks>
+            <para>
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
+            mapping subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together
+            and append the attributes.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">
+            <summary>
+            The color attributes for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The color attributes for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            An <c>AppenderCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">
+            <summary>
+            An empty readonly static AppenderCollection
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <c>AppenderCollection</c>.
+            </summary>
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">
+            <summary>
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clear">
+            <summary>
+            Removes all elements from the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>
+            in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">
+            <summary>
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">
+            <summary>
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">
+            <summary>
+            Return the collection elements as an array
+            </summary>
+            <returns>the array</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            	<para><paramref name="index"/> is less than zero</para>
+            	<para>-or-</para>
+            	<para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Appender.AspNetTraceAppender">
+            <summary>
+            <para>
+            Appends log events to the ASP.NET <see cref="T:System.Web.TraceContext"/> system.
+            </para>
+            </summary>
+            <remarks>
+            <para>
+            Diagnostic information and tracing messages that you specify are appended to the output 
+            of the page that is sent to the requesting browser. Optionally, you can view this information
+            from a separate trace viewer (Trace.axd) that displays trace information for every page in a 
+            given application.
+            </para>
+            <para>
+            Trace statements are processed and displayed only when tracing is enabled. You can control 
+            whether tracing is displayed to a page, to the trace viewer, or both.
+            </para>
+            <para>
+            The logging event is passed to the <see cref="M:TraceContext.Write(string)"/> or 
+            <see cref="M:TraceContext.Warn(string)"/> method depending on the level of the logging event.
+            The event's logger name is the default value for the category parameter of the Write/Warn method. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AspNetTraceAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the ASP.NET trace
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the ASP.NET trace
+            <c>HttpContext.Current.Trace</c> 
+            (<see cref="T:System.Web.TraceContext"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AspNetTraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.BufferingForwardingAppender">
+            <summary>
+            Buffers events and then forwards them to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The events are buffered in this appender until conditions are
+            met to allow the appender to deliver the events to the attached 
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the
+            conditions that cause the buffer to be sent.
+            </para>
+            <para>The forwarding appender can be used to specify different 
+            thresholds and filters for the same appender at different locations 
+            within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Core.IAppenderAttachable">
+            <summary>
+            Interface for attaching appenders to objects.
+            </summary>
+            <remarks>
+            <para>
+            Interface for attaching, removing and retrieving appenders.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="appender">The appender to add.</param>
+            <remarks>
+            <para>
+            Add the specified appender. The implementation may
+            choose to allow or deny duplicate appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Returns an attached appender with the <paramref name="name"/> specified.
+            If no appender with the specified name is found <c>null</c> will be
+            returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <value>
+            A collection of attached appenders.
+            </value>
+            <remarks>
+            <para>
+            Gets a collection of attached appenders.
+            If there are no attached appenders the
+            implementation should return an empty 
+            collection rather than <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            Forwards the events to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this buffering appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes directly to the application's attached console
+            not to the <c>System.Console.Out</c> or <c>System.Console.Error</c> <c>TextWriter</c>.
+            The <c>System.Console.Out</c> and <c>System.Console.Error</c> streams can be
+            programmatically redirected (for example NUnit does this to capture program output).
+            This appender will ignore these redirections because it needs to use Win32
+            API calls to colorize the output. To respect these redirections the <see cref="T:log4net.Appender.ConsoleAppender"/>
+            must be used.
+            </para>
+            <para>
+            When configuring the colored console appender, mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red, HighIntensity"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            combination of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            <item><term>HighIntensity</term><description></description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.AddMapping(log4net.Appender.ColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_consoleOutputWriter">
+            <summary>
+            The console output stream writer to write to
+            </summary>
+            <remarks>
+            <para>
+            This writer is not thread safe.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.Colors">
+            <summary>
+            The enum of possible color values for use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.ColoredConsoleAppender"/>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Purple">
+            <summary>
+            color is purple
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.HighIntensity">
+            <summary>
+            color is intensified
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> together.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> suitable for 
+            setting the console color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.DebugAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the
+            debug system.
+            </para>
+            <para>
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(string,string)"/>
+            method. The event's logger name is passed as the value for the category name to the Write method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>
+            is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_category">
+            <summary>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.Category">
+            <summary>
+            Formats the category parameter sent to the Debug method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender">
+            <summary>
+            Writes events to the system event log.
+            </summary>
+            <remarks>
+            <para>
+            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.
+            See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog
+            </para>
+            <para>
+            The <c>EventID</c> of the event log entry can be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            The <c>Category</c> of the event log entry can be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            <para>
+            When configuring the EventLogAppender a mapping can be
+            specified to map a logging level to an event log entry type. For example:
+            </para>
+            <code lang="XML">
+            &lt;mapping&gt;
+            	&lt;level value="ERROR" /&gt;
+            	&lt;eventLogEntryType value="Error" /&gt;
+            &lt;/mapping&gt;
+            &lt;mapping&gt;
+            	&lt;level value="DEBUG" /&gt;
+            	&lt;eventLogEntryType value="Information" /&gt;
+            &lt;/mapping&gt;
+            </code>
+            <para>
+            The Level is the standard log4net logging level and eventLogEntryType can be any value
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:
+            <list type="bullet">
+            <item><term>Error</term><description>an error event</description></item>
+            <item><term>Warning</term><description>a warning event</description></item>
+            <item><term>Information</term><description>an informational event</description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Thomas Voss</author>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.
+            </summary>
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">
+            <summary>
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.
+            Each mapping defines the event log entry type for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">
+            <summary>
+            Create an event log source
+            </summary>
+            <remarks>
+            Uses different API calls under NET_2_0
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Writes the event to the system event log using the 
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>
+            
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            set then this integer will be used as the event log event id.</para>
+            
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">
+            <summary>
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/>
+            </summary>
+            <param name="level">the Level to convert to an EventLogEntryType</param>
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/></returns>
+            <remarks>
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
+            values to use in logging levels than there are in the 
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is
+            a loss of information during the conversion.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">
+            <summary>
+            The log name is the section in the event logs where the messages
+            are stored.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
+            <summary>
+            Name of the application to use when logging.  This appears in the
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
+            <summary>
+            The name of the machine which holds the event log. This is
+            currently only allowed to be '.' i.e. the current machine.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to EventLogEntryType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_eventId">
+            <summary>
+            The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_category">
+            <summary>
+            The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.declaringType">
+            <summary>
+            The fully qualified type of the EventLogAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_DEFAULT">
+            <summary>
+            The maximum size supported by default.
+            </summary>
+            <remarks>
+            http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx
+            The 32766 documented max size is two bytes shy of 32K (I'm assuming 32766 
+            may leave space for a two byte null terminator of #0#0). The 32766 max 
+            length is what the .NET 4.0 source code checks for, but this is WRONG! 
+            Strings with a length > 31839 on Windows Vista or higher can CORRUPT 
+            the event log! See: System.Diagnostics.EventLogInternal.InternalWriteEvent() 
+            for the use of the 32766 max size.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_VISTA_OR_NEWER">
+            <summary>
+            The maximum size supported by a windows operating system that is vista
+            or newer.
+            </summary>
+            <remarks>
+            See ReportEvent API:
+            	http://msdn.microsoft.com/en-us/library/aa363679(VS.85).aspx
+            ReportEvent's lpStrings parameter:
+            "A pointer to a buffer containing an array of 
+            null-terminated strings that are merged into the message before Event Viewer 
+            displays the string to the user. This parameter must be a valid pointer 
+            (or NULL), even if wNumStrings is zero. Each string is limited to 31,839 characters."
+            
+            Going beyond the size of 31839 will (at some point) corrupt the event log on Windows
+            Vista or higher! It may succeed for a while...but you will eventually run into the
+            error: "System.ComponentModel.Win32Exception : A device attached to the system is
+            not functioning", and the event log will then be corrupt (I was able to corrupt 
+            an event log using a length of 31877 on Windows 7).
+            
+            The max size for Windows Vista or higher is documented here:
+            	http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx.
+            Going over this size may succeed a few times but the buffer will overrun and 
+            eventually corrupt the log (based on testing).
+            
+            The maxEventMsgSize size is based on the max buffer size of the lpStrings parameter of the ReportEvent API.
+            The documented max size for EventLog.WriteEntry for Windows Vista and higher is 31839, but I'm leaving room for a
+            terminator of #0#0, as we cannot see the source of ReportEvent (though we could use an API monitor to examine the
+            buffer, given enough time).
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE">
+            <summary>
+            The maximum size that the operating system supports for
+            a event log message.
+            </summary>
+            <remarks>
+            Used to determine the maximum string length that can be written
+            to the operating system event log and eventually truncate a string
+            that exceeds the limits.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetMaxEventLogMessageSize">
+            <summary>
+            This method determines the maximum event log message size allowed for
+            the current environment.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.LogName">
+            <summary>
+            The name of the log where messages will be stored.
+            </summary>
+            <value>
+            The string name of the log where messages will be stored.
+            </value>
+            <remarks>
+            <para>This is the name of the log as it appears in the Event Viewer
+            tree. The default value is to log into the <c>Application</c>
+            log, this is where most applications write their events. However
+            if you need a separate log for your application (or applications)
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
+            <para>This should not be used to distinguish your event log messages
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
+            property should be used to distinguish events. This property should be 
+            used to group together events into a single log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
+            <summary>
+            Property used to set the Application name.  This appears in the
+            event logs when logging.
+            </summary>
+            <value>
+            The string used to distinguish events from different sources.
+            </value>
+            <remarks>
+            Sets the event log source property.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">
+            <summary>
+            This property is used to return the name of the computer to use
+            when accessing the event logs.  Currently, this is the current
+            computer, denoted by a dot "."
+            </summary>
+            <value>
+            The string name of the machine holding the event log that 
+            will be logged into.
+            </value>
+            <remarks>
+            This property cannot be changed. It is currently set to '.'
+            i.e. the local machine. This may be changed in future.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </value>
+            <remarks>
+            <para>
+            The system security context used to write to the EventLog.
+            </para>
+            <para>
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.EventId">
+            <summary>
+            Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>EventID</c> of the event log entry will normally be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Category">
+            <summary>
+            Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Category</c> of the event log entry will normally be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and its event log entry type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">
+            <summary>
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender">
+            <summary>
+            Appends logging events to a file.
+            </summary>
+            <remarks>
+            <para>
+            Logging events are sent to the file specified by
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.
+            </para>
+            <para>
+            The file can be opened in either append or overwrite mode 
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.
+            If the file path is relative it is taken as relative from 
+            the application base directory. The file encoding can be
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.
+            </para>
+            <para>
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            values will be written each time the file is opened and closed
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>
+            then the file may contain multiple copies of the header and footer.
+            </para>
+            <para>
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> 
+            is to obtain an exclusive write lock on the file until this appender is closed.
+            The alternative models only hold a
+            write lock while the appender is writing a logging event (<see cref="T:log4net.Appender.FileAppender.MinimalLock"/>)
+            or synchronize by using a named system wide Mutex (<see cref="T:log4net.Appender.FileAppender.InterProcessLock"/>).
+            </para>
+            <para>
+            All locking strategies have issues and you should seriously consider using a different strategy that
+            avoids having multiple processes logging to the same file.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Rodrigo B. de Oliveira</author>
+            <author>Douglas de la Torre</author>
+            <author>Niall Daley</author>
+        </member>
+        <member name="T:log4net.Appender.TextWriterAppender">
+            <summary>
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This appender may be used stand alone if initialized with an appropriate
+            writer, however it is typically used as a base class for an appender that
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized 
+            with the specified <see cref="T:System.IO.Stream"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender</param>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
+            <remarks>
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
+            <summary>
+            This method determines if there is a sense in attempting to append.
+            </summary>
+            <remarks>
+            <para>
+            This method checks if an output target has been set and if a
+            layout has been set. 
+            </para>
+            </remarks>
+            <returns><c>false</c> if any of the preconditions fail.</returns>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method writes all the bulk logged events to the output writer
+            before flushing the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+            <remarks>
+            Closed appenders cannot be reused.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
+            <summary>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">
+            <summary>
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> 
+            and other variables.
+            </summary>
+            <remarks>
+            <para>
+            Subclasses can override this method for an alternate closing behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
+            <summary>
+            Called to allow a subclass to lazily initialize the writer
+            </summary>
+            <remarks>
+            <para>
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
+            attempt to initialize the writer multiple times.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
+            <summary>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> 
+            or output stream will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logging events are not actually persisted if and when the application 
+            crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.declaringType">
+            <summary>
+            The fully qualified type of the TextWriterAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
+            <summary>
+            Gets or set whether the appender will flush at the end 
+            of each append operation.
+            </summary>
+            <value>
+            <para>
+            The default behavior is to flush at the end of each 
+            append operation.
+            </para>
+            <para>
+            If this option is set to <c>false</c>, then the underlying 
+            stream can defer persisting the logging event to a later 
+            time.
+            </para>
+            </value>
+            <remarks>
+            Avoiding the flush operation at the end of each append results in
+            a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">
+            <summary>
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
+            </summary>
+            <remarks>
+            <para>
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
+            </para>
+            <para>
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender 
+            instance is closed.
+            </para>
+            <para>
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
+            <summary>
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying 
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </value>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
+            </value>
+            <remarks>
+            <para>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
+            <summary>
+            Construct a new appender using the layout, file and append mode.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <param name="append">flag to indicate if the file should be appended to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
+            <summary>
+            Construct a new appender using the layout and file specified.
+            The file will be appended to.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
+            <summary>
+            Activate the options on the file appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This will cause the file to be opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Reset">
+            <summary>
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.
+            </summary>
+            <remarks>
+            <para>
+            Resets the filename and the file stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">
+            <summary>
+            Called to initialize the file writer
+            </summary>
+            <remarks>
+            <para>
+            Will be called for each logged message until the file is
+            successfully opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Acquires the output file locks once before writing all the events to
+            the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseFile">
+            <summary>
+            Closes the previously opened file.
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then
+            closes the file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            If there was already an opened file, then the previous file
+            is closed first.
+            </para>
+            <para>
+            This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">
+            <summary>
+            Sets the quiet writer used for file output
+            </summary>
+            <param name="fileStream">the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This implementation of <see cref="M:SetQWForFiles(Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>
+            over the <paramref name="fileStream"/> and passes it to the 
+            <see cref="M:SetQWForFiles(TextWriter)"/> method.
+            </para>
+            <para>
+            This method can be overridden by sub classes that want to wrap the
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <param name="writer">the writer over the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This method can be overridden by sub classes that want to
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
+            <summary>
+            Flag to indicate if we should append to the file
+            or overwrite the file. The default is to append.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_fileName">
+            <summary>
+            The name of the log file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_encoding">
+            <summary>
+            The encoding to use for the file stream.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_stream">
+            <summary>
+            The stream to log to. Has added locking semantics
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">
+            <summary>
+            The locking model to use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.declaringType">
+            <summary>
+            The fully qualified type of the FileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.File">
+            <summary>
+            Gets or sets the path to the file that logging will be written to.
+            </summary>
+            <value>
+            The path to the file that logging will be written to.
+            </value>
+            <remarks>
+            <para>
+            If the path is relative it is taken as relative from 
+            the application base directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">
+            <summary>
+            Gets or sets a flag that indicates whether the file should be
+            appended to or overwritten.
+            </summary>
+            <value>
+            Indicates whether the file should be appended to or overwritten.
+            </value>
+            <remarks>
+            <para>
+            If the value is set to false then the file will be overwritten, if 
+            it is set to true then the file will be appended to.
+            </para>
+            The default value is true.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>
+            which is the encoding for the system's current ANSI code page.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModel">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </para>
+            <para>
+            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"/> .
+            The first locks the file from the start of logging to the end, the 
+            second locks only for the minimal amount of time when logging each message
+            and the last synchronizes processes using a named system wide Mutex.
+            </para>
+            <para>
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingStream">
+            <summary>
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> 
+            to manage access to an underlying resource.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
+            <summary>
+            True asynchronous writes are not supported, the implementation forces a synchronous write.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LogException">
+            <summary>
+            Exception base type for log4net.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with
+            the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">
+            <summary>
+            Locking model base class
+            </summary>
+            <remarks>
+            <para>
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the output file
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CreateStream(System.String,System.Boolean,System.IO.FileShare)">
+            <summary>
+            Helper method that creates a FileStream under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            <para>
+            Typically called during OpenFile or AcquireLock. 
+            </para>
+            <para>
+            If the directory portion of the <paramref name="filename"/> does not exist, it is created
+            via Directory.CreateDirecctory.
+            </para>
+            </remarks>
+            <param name="filename"></param>
+            <param name="append"></param>
+            <param name="fileShare"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseStream(System.IO.Stream)">
+            <summary>
+            Helper method to close <paramref name="stream"/> under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            Does not set <paramref name="stream"/> to null.
+            </remarks>
+            <param name="stream"></param>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </summary>
+            <value>
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </value>
+            <remarks>
+            <para>
+            The file appender this locking model is attached to and working on
+            behalf of.
+            </para>
+            <para>
+            The file appender is used to locate the security context and the error handler to use.
+            </para>
+            <para>
+            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
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">
+            <summary>
+            Hold an exclusive lock on the output file
+            </summary>
+            <remarks>
+            <para>
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. 
+            Maintains an exclusive lock on the file during this time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Does nothing. The lock will be released when the file is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">
+            <summary>
+            Acquires the file lock for each write
+            </summary>
+            <remarks>
+            <para>
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, 
+            thus holding the lock for the minimal amount of time. This method of locking
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows 
+            other processes to move/delete the log file whilst logging continues.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Prepares to open the file when the first message is logged.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.InterProcessLock">
+            <summary>
+            Provides cross-process file locking.
+            </summary>
+            <author>Ron Grabowski</author>
+            <author>Steve Wranovsky</author>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/>,
+            -<see cref="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock">
+            <summary>
+            Releases the lock and allows others to acquire a lock.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ForwardingAppender">
+            <summary>
+            This appender forwards logging events to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The forwarding appender can be used to specify different thresholds
+            and filters for the same appender at different locations within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Forward the logging event to the attached appenders 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Forward the logging events to the attached appenders 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging events to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender">
+            <summary>
+            Logs events to a local syslog service.
+            </summary>
+            <remarks>
+            <note>
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.
+            If these functions are not available on the local system then this appender will not work!
+            </note>
+            <para>
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and 
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.
+            </para>
+            <para>
+            This appender talks to a local syslog service. If you need to log to a remote syslog
+            daemon and you cannot configure your local syslog service to do this you may be
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write 
+            to a local syslog service.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">
+            <summary>
+            Close the syslog when the appender is closed
+            </summary>
+            <remarks>
+            <para>
+            Close the syslog when the appender is closed
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">
+            <summary>
+            Marshaled handle to the identity string. We have to hold on to the
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the
+            pointer to the ident and dereference it for each log message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">
+            <summary>
+            Open connection to system logger.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">
+            <summary>
+            Generate a log message.
+            </summary>
+            <remarks>
+            <para>
+            The libc syslog method takes a format string and a variable argument list similar
+            to the classic printf function. As this type of vararg list is not supported
+            by C# we need to specify the arguments explicitly. Here we have specified the
+            format string with a single message argument. The caller must set the format 
+            string to <c>"%s"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">
+            <summary>
+            Close descriptor used to write to system logger.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The log4net Level maps to a syslog severity using the
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facility defines which subsystem the logging comes from.
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender">
+            <summary>
+            Appends colorful logging events to the console, using the .NET 2
+            built-in capabilities.
+            </summary>
+            <remarks>
+            <para>
+            ManagedColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            When configuring the colored console appender, mappings should be
+            specified to map logging levels to colors. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="DarkRed"/>
+            	<backColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="WARN"/>
+            	<foreColor value="Yellow"/>
+            </mapping>
+            <mapping>
+            	<level value="INFO"/>
+            	<foreColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<foreColor value="Blue"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level while
+            ForeColor and BackColor are the values of <see cref="T:System.ConsoleColor"/>
+            enumeration.
+            </para>
+            <para>
+            Based on the ColoredConsoleAppender
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+            <author>Pavlos Touboulidis</author>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.AddMapping(log4net.Appender.ManagedColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.MemoryAppender">
+            <summary>
+            Stores logging events in an array.
+            </summary>
+            <remarks>
+            <para>
+            The memory appender stores all the logging events
+            that are appended in an in-memory array.
+            </para>
+            <para>
+            Use the <see cref="M:PopAllEvents()"/> method to get
+            and clear the current list of events that have been appended.
+            </para>
+            <para>
+            Use the <see cref="M:GetEvents()"/> method to get the current
+            list of events that have been appended.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            <para>
+            Use the <see cref="M:Clear()"/> method to clear the
+            current list of events.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            </remarks>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">
+            <summary>
+            Gets the events that have been logged.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Clear">
+            <summary>
+            Clear the list of events
+            </summary>
+            <remarks>
+            Clear the list of events
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.PopAllEvents">
+            <summary>
+            Gets the events that have been logged and clears the list of events.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged and clears the list of events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
+            <summary>
+            The list of events that have been appended.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating whether only part of the logging event 
+            data should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the event 
+            data to be fixed and stored in the appender, hereby improving performance. 
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(bool)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.Fix">
+            <summary>
+            Gets or sets the fields that will be fixed in the event
+            </summary>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.NetSendAppender">
+            <summary>
+            Logs entries by sending network messages using the 
+            <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> native function.
+            </summary>
+            <remarks>
+            <para>
+            You can send messages only to names that are active 
+            on the network. If you send the message to a user name, 
+            that user must be logged on and running the Messenger 
+            service to receive the message.
+            </para>
+            <para>
+            The receiver will get a top most window displaying the 
+            messages one at a time, therefore this appender should 
+            not be used to deliver a high volume of messages.
+            </para>
+            <para>
+            The following table lists some possible uses for this appender :
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Action</term>
+                    <description>Property Value(s)</description>
+                </listheader>
+                <item>
+                    <term>Send a message to a user account on the local machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a user account on a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the remote machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a domain user account</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of a domain controller | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to all the names in a workgroup or domain</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;workgroup name | domain name&gt;*
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message from the local machine to a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;name of the remote machine&gt;
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            <b>Note :</b> security restrictions apply for sending 
+            network messages, see <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> 
+            for more information.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            An example configuration section to log information 
+            using this appender from the local machine, named 
+            LOCAL_PC, to machine OPERATOR_PC :
+            </para>
+            <code lang="XML" escaped="true">
+            <appender name="NetSendAppender_Operator" type="log4net.Appender.NetSendAppender">
+                <server value="LOCAL_PC"/>
+                <recipient value="OPERATOR_PC"/>
+                <layout type="log4net.Layout.PatternLayout" value="%-5p %c [%x] - %m%n"/>
+            </appender>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_server">
+            <summary>
+            The DNS or NetBIOS name of the server on which the function is to execute.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_sender">
+            <summary>
+            The sender of the network message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_recipient">
+            <summary>
+            The message alias to which the message should be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.#ctor">
+            <summary>
+            Initializes the appender.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was not specified.</exception>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using a network message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)">
+            <summary>
+            Sends a buffer of information to a registered message alias.
+            </summary>
+            <param name="serverName">The DNS or NetBIOS name of the server on which the function is to execute.</param>
+            <param name="msgName">The message alias to which the message buffer should be sent</param>
+            <param name="fromName">The originator of the message.</param>
+            <param name="buffer">The message text.</param>
+            <param name="bufferSize">The length, in bytes, of the message text.</param>
+            <remarks>
+            <para>
+            The following restrictions apply for sending network messages:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Platform</term>
+                    <description>Requirements</description>
+                </listheader>
+                <item>
+                    <term>Windows NT</term>
+                    <description>
+                        <para>
+                        No special group membership is required to send a network message.
+                        </para>
+                        <para>
+                        Admin, Accounts, Print, or Server Operator group membership is required to 
+                        successfully send a network message on a remote server.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Windows 2000 or later</term>
+                    <description>
+                        <para>
+                        If you send a message on a domain controller that is running Active Directory, 
+                        access is allowed or denied based on the access control list (ACL) for the securable 
+                        object. The default ACL permits only Domain Admins and Account Operators to send a network message. 
+                        </para>
+                        <para>
+                        On a member server or workstation, only Administrators and Server Operators can send a network message. 
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            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>.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is zero.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Sender">
+            <summary>
+            Gets or sets the sender of the message.
+            </summary>
+            <value>
+            The sender of the message.
+            </value>
+            <remarks>
+            If this property is not specified, the message is sent from the local computer.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Recipient">
+            <summary>
+            Gets or sets the message alias to which the message should be sent.
+            </summary>
+            <value>
+            The recipient of the message.
+            </value>
+            <remarks>
+            This property should always be specified in order to send a message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Server">
+            <summary>
+            Gets or sets the DNS or NetBIOS name of the remote server on which the function is to execute.
+            </summary>
+            <value>
+            DNS or NetBIOS name of the remote server on which the function is to execute.
+            </value>
+            <remarks>
+            <para>
+            For Windows NT 4.0 and earlier, the string should begin with \\.
+            </para>
+            <para>
+            If this property is not specified, the local computer is used. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.OutputDebugStringAppender">
+            <summary>
+            Appends log events to the OutputDebugString system.
+            </summary>
+            <remarks>
+            <para>
+            OutputDebugStringAppender appends log events to the
+            OutputDebugString system.
+            </para>
+            <para>
+            The string is passed to the native <c>OutputDebugString</c> 
+            function.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.OutputDebugStringAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the output debug string API
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the output debug string API
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">
+            <summary>
+            Stub for OutputDebugString native method
+            </summary>
+            <param name="message">the string to output</param>
+            <remarks>
+            <para>
+            Stub for OutputDebugString native method
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.OutputDebugStringAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender">
+            <summary>
+            Logs events to a remote syslog daemon.
+            </summary>
+            <remarks>
+            <para>
+            The BSD syslog protocol is used to remotely log to
+            a syslog daemon. The syslogd listens for for messages
+            on UDP port 514.
+            </para>
+            <para>
+            The syslog UDP protocol is not authenticated. Most syslog daemons
+            do not accept remote log messages because of the security implications.
+            You may be able to use the LocalSyslogAppender to talk to a local
+            syslog service.
+            </para>
+            <para>
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.
+            This appender generates what the RFC calls an "Original Device Message",
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation
+            this format of message will be accepted by all current syslog daemon
+            implementations. The daemon will attach the current time and the source
+            hostname or IP address to any messages received.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Appender.UdpAppender">
+             <summary>
+             Sends logging events as connectionless UDP datagrams to a remote host or a 
+             multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.
+             </summary>
+             <remarks>
+             <para>
+             UDP guarantees neither that messages arrive, nor that they arrive in the correct order.
+             </para>
+             <para>
+             To view the logging results, a custom application can be developed that listens for logging 
+             events.
+             </para>
+             <para>
+             When decoding events send via this appender remember to use the same encoding
+             to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>
+             property to specify the encoding to use.
+             </para>
+             </remarks>
+             <example>
+             This example shows how to log receive logging events that are sent 
+             on IP address 244.0.0.1 and port 8080 to the console. The event is 
+             encoded in the packet as a unicode string and it is decoded as such. 
+             <code lang="C#">
+             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+             UdpClient udpClient;
+             byte[] buffer;
+             string loggingEvent;
+             
+             try 
+             {
+                 udpClient = new UdpClient(8080);
+                 
+                 while(true) 
+                 {
+                     buffer = udpClient.Receive(ref remoteEndPoint);
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
+                     Console.WriteLine(loggingEvent);
+                 }
+             } 
+             catch(Exception e) 
+             {
+                 Console.WriteLine(e.ToString());
+             }
+             </code>
+             <code lang="Visual Basic">
+             Dim remoteEndPoint as IPEndPoint
+             Dim udpClient as UdpClient
+             Dim buffer as Byte()
+             Dim loggingEvent as String
+             
+             Try 
+                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
+                 udpClient = new UdpClient(8080)
+            
+                 While True
+                     buffer = udpClient.Receive(ByRef remoteEndPoint)
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
+                     Console.WriteLine(loggingEvent)
+                 Wend
+             Catch e As Exception
+                 Console.WriteLine(e.ToString())
+             End Try
+             </code>
+             <para>
+             An example configuration section to log information using this appender to the 
+             IP 224.0.0.1 on port 8080:
+             </para>
+             <code lang="XML" escaped="true">
+             <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
+                 <remoteAddress value="224.0.0.1"/>
+                 <remotePort value="8080"/>
+                 <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>
+             </appender>
+             </code>
+             </example>
+             <author>Gert Driesen</author>
+             <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or 
+            an invalid remote or local TCP port number was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>
+            <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>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using an UDP datagram.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.OnClose">
+            <summary>
+            Closes the UDP connection and releases all resources associated with 
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed 
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">
+            <summary>
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.
+            </summary>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the 
+            port number from which you intend to communicate.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">
+            <summary>
+            The IP address of the remote host or multicast group to which 
+            the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">
+            <summary>
+            The TCP port number of the remote host or multicast group to 
+            which the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">
+            <summary>
+            The cached remote endpoint to which the logging events will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">
+            <summary>
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_client">
+            <summary>
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the 
+            logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">
+            <summary>
+            The encoding to use for the packet.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">
+            <summary>
+            Gets or sets the IP address of the remote host or multicast group to which
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            The IP address of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            <para>
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so
+            it is possible to use multicasts in an Internet scenario as long as your network provider 
+            supports multicasting.
+            </para>
+            <para>
+            Hosts that want to receive particular multicast messages must register their interest by joining
+            the multicast group.  Multicast messages are not sent to networks where no host has joined
+            the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
+            them from normal host addresses, allowing nodes to easily detect if a message is of interest.
+            </para>
+            <para>
+            Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>IP Address</term>
+                    <description>Description</description>
+                </listheader>
+                <item>
+                    <term>224.0.0.1</term>
+                    <description>
+                        <para>
+                        Sends a message to all system on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.2</term>
+                    <description>
+                        <para>
+                        Sends a message to all routers on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.12</term>
+                    <description>
+                        <para>
+                        The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            A complete list of actually reserved multicast addresses and their owners in the ranges
+            defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
+            </para>
+            <para>
+            The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
+            addresses.  These addresses can be reused with other local groups.  Routers are typically 
+            configured with filters to prevent multicast traffic in this range from flowing outside
+            of the local network.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemotePort">
+            <summary>
+            Gets or sets the TCP port number of the remote host or multicast group to which 
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will send messages to this TCP port number
+            on the remote host or multicast group.
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.LocalPort">
+            <summary>
+            Gets or sets the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </value>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will bind to this port for sending messages.
+            </para>
+            <para>
+            Setting the value to 0 (the default) will cause the udp client not to bind to
+            a local port.
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Client">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.UdpAppender"/> creates a <see cref="T:System.Net.Sockets.UdpClient"/> to send logging events 
+            over a network.  Classes deriving from <see cref="T:log4net.Appender.UdpAppender"/> can use this
+            property to get or set this <see cref="T:System.Net.Sockets.UdpClient"/>.  Use the underlying <see cref="T:System.Net.Sockets.UdpClient"/>
+            returned from <see cref="P:log4net.Appender.UdpAppender.Client"/> if you require access beyond that which 
+            <see cref="T:log4net.Appender.UdpAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteEndPoint">
+            <summary>
+            Gets or sets the cached remote endpoint to which the logging events should be sent.
+            </summary>
+            <value>
+            The cached remote endpoint to which the logging events will be sent.
+            </value>
+            <remarks>
+            The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method will initialize the remote endpoint 
+            with the values of the <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> and <see cref="P:log4net.Appender.UdpAppender.RemotePort"/>
+            properties.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.DefaultSyslogPort">
+            <summary>
+            Syslog port 514
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class is set up to write 
+            to a remote syslog daemon.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.AddMapping(log4net.Appender.RemoteSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity"/> mapping to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to syslog severity mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GeneratePriority(log4net.Appender.RemoteSyslogAppender.SyslogFacility,log4net.Appender.RemoteSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+            <remarks>
+            <para>
+            Generate a syslog priority.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The syslog severities.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facilities
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender">
+            <summary>
+            Delivers logging events to a remote logging sink. 
+            </summary>
+            <remarks>
+            <para>
+            This Appender is designed to deliver events to a remote sink. 
+            That is any object that implements the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface. It delivers the events using .NET remoting. The
+            object to deliver events to is specified by setting the
+            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.</para>
+            <para>
+            The RemotingAppender buffers events before sending them. This allows it to 
+            make more efficient use of the remoting infrastructure.</para>
+            <para>
+            Once the buffer is full the events are still not sent immediately. 
+            They are scheduled to be sent using a pool thread. The effect is that 
+            the send occurs asynchronously. This is very important for a 
+            number of non obvious reasons. The remoting infrastructure will 
+            flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.</para>
+            <para>
+            Because the events are sent asynchronously using pool threads it is possible to close 
+            this appender before all the queued events have been sent.
+            When closing the appender attempts to wait until all the queued events have been sent, but 
+            this will timeout after 30 seconds regardless.</para>
+            <para>
+            If this appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for. If the runtime terminates the threads before
+            the queued events have been sent then they will be lost. To ensure that all events
+            are sent the appender must be closed before the application exits. See 
+            <see cref="M:log4net.Core.LoggerManager.Shutdown"/> for details on how to shutdown
+            log4net programmatically.</para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemotingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            The events are not sent immediately. They are scheduled to be sent
+            using a pool thread. The effect is that the send occurs asynchronously.
+            This is very important for a number of non obvious reasons. The remoting
+            infrastructure will flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.
+            </remarks>
+            <param name="events">The events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.OnClose">
+            <summary>
+            Override base class close.
+            </summary>
+            <remarks>
+            <para>
+            This method waits while there are queued work items. The events are
+            sent asynchronously using <see cref="T:System.Threading.ThreadPool"/> work items. These items
+            will be sent once a thread pool thread is available to send them, therefore
+            it is possible to close the appender before all the queued events have been
+            sent.</para>
+            <para>
+            This method attempts to wait until all the queued events have been sent, but this 
+            method will timeout after 30 seconds regardless.</para>
+            <para>
+            If the appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.BeginAsyncSend">
+            <summary>
+            A work item is being queued into the thread pool
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.EndAsyncSend">
+            <summary>
+            A work item from the thread pool has completed
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBufferCallback(System.Object)">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            This method is designed to be used with the <see cref="T:System.Threading.ThreadPool"/>.
+            This method expects to be passed an array of <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the state param.
+            </remarks>
+            <param name="state">the logging events to send</param>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">
+            <summary>
+            The URL of the remote sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">
+            <summary>
+            The local proxy (.NET remoting) for the remote logging sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_queuedCallbackCount">
+            <summary>
+            The number of queued callbacks currently waiting or executing
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_workQueueEmptyEvent">
+            <summary>
+            Event used to signal when there are no queued work items
+            </summary>
+            <remarks>
+            This event is set when there are no queued work items. In this
+            state it is safe to close the appender.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemotingAppender.Sink">
+            <summary>
+            Gets or sets the URL of the well-known object that will accept 
+            the logging events.
+            </summary>
+            <value>
+            The well-known URL of the remote sink.
+            </value>
+            <remarks>
+            <para>
+            The URL of the remoting sink that will accept logging events.
+            The sink must implement the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink">
+            <summary>
+            Interface used to deliver <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            This interface must be implemented by a remoting sink
+            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used
+            to deliver logging events to the sink.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.IRemoteLoggingSink.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Delivers logging events to the remote sink
+            </summary>
+            <param name="events">Array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers logging events to the remote sink
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender">
+            <summary>
+            Appender that rolls log files based on size or date or both.
+            </summary>
+            <remarks>
+            <para>
+            RollingFileAppender can roll log files based on size or date or both
+            depending on the setting of the <see cref="P:log4net.Appender.RollingFileAppender.RollingStyle"/> property.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Size"/> the log file will be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Date"/> the log file will be rolled
+            once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/> the log file will be
+            rolled once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed, but within a date boundary the file will also be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> the log file will be rolled when
+            the appender is configured. This effectively means that the log file can be
+            rolled once per program execution.
+            </para>
+            <para>
+            A of few additional optional features have been added:
+            <list type="bullet">
+            <item>Attach date pattern for current log file <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/></item>
+            <item>Backup number increments for newer files <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/></item>
+            <item>Infinite number of backups by file size <see cref="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups"/></item>
+            </list>
+            </para>
+            
+            <note>
+            <para>
+            For large or infinite numbers of backup files a <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> 
+            greater than zero is highly recommended, otherwise all the backup files need
+            to be renamed each time a new backup is created.
+            </para>
+            <para>
+            When Date/Time based rolling is used setting <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> 
+            to <see langword="true"/> will reduce the number of file renamings to few or none.
+            </para>
+            </note>
+            
+            <note type="caution">
+            <para>
+            Changing <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> or <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> without clearing
+            the log file directory of backup files will cause unexpected and unwanted side effects.  
+            </para>
+            </note>
+            
+            <para>
+            If Date/Time based rolling is enabled this appender will attempt to roll existing files
+            in the directory without a Date/Time tag based on the last write date of the base log file.
+            The appender only rolls the log file when a message is logged. If Date/Time based rolling 
+            is enabled then the appender will not roll the log file at the Date/Time boundary but
+            at the point when the next message is logged after the boundary has been crossed.
+            </para>
+            
+            <para>
+            The <see cref="T:log4net.Appender.RollingFileAppender"/> extends the <see cref="T:log4net.Appender.FileAppender"/> and
+            has the same behavior when opening the log file.
+            The appender will first try to open the file for writing when <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            When rolling a backup file necessitates deleting an older backup file the
+            file to be deleted is moved to a temporary name before being deleted.
+            </para>
+            
+            <note type="caution">
+            <para>
+            A maximum number of backup files when rolling on date/time boundaries is not supported.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Edward Smit</author>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RollingFileAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Finalize">
+            <summary>
+            Cleans up all resources used by this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.declaringType">
+            <summary>
+            The fully qualified type of the RollingFileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <remarks>
+            This method can be overridden by sub classes.
+            </remarks>
+            <param name="writer">the writer to set</param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write out a logging event.
+            </summary>
+            <param name="loggingEvent">the event to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Write out an array of logging events.
+            </summary>
+            <param name="loggingEvents">the events to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.AdjustFileBeforeAppend">
+            <summary>
+            Performs any required rolling before outputting the next event
+            </summary>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Creates and opens the file for logging.  If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/>
+            is false then the fully qualified name is determined and used.
+            </summary>
+            <param name="fileName">the name of the file to open</param>
+            <param name="append">true to append to existing file</param>
+            <remarks>
+            <para>This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetNextOutputFileName(System.String)">
+            <summary>
+            Get the current output file name
+            </summary>
+            <param name="fileName">the base file name</param>
+            <returns>the output file name</returns>
+            <remarks>
+            The output file name is based on the base fileName specified.
+            If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> is set then the output 
+            file name is the same as the base file passed in. Otherwise
+            the output file depends on the date pattern, on the count
+            direction or both.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DetermineCurSizeRollBackups">
+            <summary>
+            Determines curSizeRollBackups (only within the current roll point)
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">
+            <summary>
+            Generates a wildcard pattern that can be used to find all files
+            that are similar to the base file name.
+            </summary>
+            <param name="baseFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">
+            <summary>
+            Builds a list of filenames for all files matching the base filename plus a file
+            pattern.
+            </summary>
+            <param name="baseFilePath"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">
+            <summary>
+            Initiates a roll over if needed for crossing a date boundary since the last run.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">
+            <summary>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            </summary>
+            <remarks>
+            <para>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            The following is done
+            <list type="bullet">
+            <item>determine curSizeRollBackups (only within the current roll point)</item>
+            <item>initiates a roll over if needed for crossing a date boundary since the last run.</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">
+            <summary>
+            Does the work of bumping the 'current' file counter higher
+            to the highest count when an incremental file name is seen.
+            The highest count is either the first file (when count direction
+            is greater than 0) or the last file (when count direction less than 0).
+            In either case, we want to know the highest count that is present.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="curFileName"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetBackUpIndex(System.String)">
+            <summary>
+            Attempts to extract a number from the end of the file name that indicates
+            the number of the times the file has been rolled over.
+            </summary>
+            <remarks>
+            Certain date pattern extensions like yyyyMMdd will be parsed as valid backup indexes.
+            </remarks>
+            <param name="curFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">
+            <summary>
+            Takes a list of files and a base file name, and looks for 
+            'incremented' versions of the base file.  Bumps the max
+            count up to the highest count seen.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="arrayFiles"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod(System.String)">
+            <summary>
+            Calculates the RollPoint for the datePattern supplied.
+            </summary>
+            <param name="datePattern">the date pattern to calculate the check period for</param>
+            <returns>The RollPoint that is most accurate for the date pattern supplied</returns>
+            <remarks>
+            Essentially the date pattern is examined to determine what the
+            most suitable roll point is. The roll point chosen is the roll point
+            with the smallest period that can be detected using the date pattern
+            supplied. i.e. if the date pattern only outputs the year, month, day 
+            and hour then the smallest roll point that can be detected would be
+            and hourly roll point as minutes could not be detected.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Sets initial conditions including date/time roll over information, first check,
+            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize
+            the current number of backups.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.CombinePath(System.String,System.String)">
+            <summary>
+            
+            </summary>
+            <param name="path1"></param>
+            <param name="path2">.1, .2, .3, etc.</param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime(System.Boolean)">
+            <summary>
+            Rollover the file(s) to date/time tagged file(s).
+            </summary>
+            <param name="fileIsOpen">set to true if the file to be rolled is currently open</param>
+            <remarks>
+            <para>
+            Rollover the file(s) to date/time tagged file(s).
+            Resets curSizeRollBackups. 
+            If fileIsOpen is set then the new file is opened (through SafeOpenFile).
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">
+            <summary>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>.
+            </summary>
+            <param name="fromFile">Name of existing file to roll.</param>
+            <param name="toFile">New name for file.</param>
+            <remarks>
+            <para>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. It
+            also checks for existence of target file and deletes if it does.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.FileExists(System.String)">
+            <summary>
+            Test if a file exists at a specified path
+            </summary>
+            <param name="path">the path to the file</param>
+            <returns>true if the file exists</returns>
+            <remarks>
+            <para>
+            Test if a file exists at a specified path
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">
+            <summary>
+            Deletes the specified file if it exists.
+            </summary>
+            <param name="fileName">The file to delete.</param>
+            <remarks>
+            <para>
+            Delete a file if is exists.
+            The file is first moved to a new filename then deleted.
+            This allows the file to be removed even when it cannot
+            be deleted, but it still can be moved.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">
+            <summary>
+            Implements file roll base on file size.
+            </summary>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. Moreover, <c>File</c> is
+            renamed <c>File.1</c> and closed.
+            </para>
+            <para>
+            A new file is created to receive further log output.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverRenameFiles(System.String)">
+            <summary>
+            Implements file roll.
+            </summary>
+            <param name="baseFileName">the base name to rename</param>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. 
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            <para>
+            This is called by <see cref="M:log4net.Appender.RollingFileAppender.RollOverSize"/> to rename the files.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">
+            <summary>
+            Get the start time of the next window for the current rollpoint
+            </summary>
+            <param name="currentDateTime">the current date</param>
+            <param name="rollPoint">the type of roll point we are working with</param>
+            <returns>the start time for the next roll point an interval after the currentDateTime date</returns>
+            <remarks>
+            <para>
+            Returns the date of the next roll point after the currentDateTime date passed to the method.
+            </para>
+            <para>
+            The basic strategy is to subtract the time parts that are less significant
+            than the rollpoint from the current time. This should roll the time back to
+            the start of the time window for the current rollpoint. Then we add 1 window
+            worth of time and get the start time of the next window for the rollpoint.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">
+            <summary>
+            This object supplies the current date/time.  Allows test code to plug in
+            a method to control this class when testing date/time based rolling. The default
+            implementation uses the underlying value of DateTime.Now.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">
+            <summary>
+            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> 
+            meaning daily rollover.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">
+            <summary>
+            The actual formatted filename that is currently being written to
+            or will be the file transferred to on roll over
+            (based on staticLogFileName).
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">
+            <summary>
+            The timestamp when we shall next recompute the filename.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_now">
+            <summary>
+            Holds date of last roll over
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">
+            <summary>
+            The type of rolling done
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">
+            <summary>
+            The default maximum file size is 10MB
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">
+            <summary>
+            There is zero backup files by default
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">
+            <summary>
+            How many sized based backups have been made so far
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">
+            <summary>
+            The rolling file count direction. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">
+            <summary>
+            The rolling mode used in this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">
+            <summary>
+            Cache flag set if we are rolling by date.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">
+            <summary>
+            Cache flag set if we are rolling by size.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">
+            <summary>
+            Value indicating whether to always log to the same file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_preserveLogFileNameExtension">
+            <summary>
+            Value indicating whether to preserve the file name extension when rolling.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">
+            <summary>
+            FileName provided in configuration.  Used for rolling properly
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_mutexForRolling">
+            <summary>
+            A mutex that is used to lock rolling of files.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DateTimeStrategy">
+            <summary>
+            Gets or sets the strategy for determining the current date and time. The default
+            implementation is to use LocalDateTime which internally calls through to DateTime.Now. 
+            DateTime.UtcNow may be used on frameworks newer than .NET 1.0 by specifying
+            <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </summary>
+            <value>
+            An implementation of the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> interface which returns the current date and time.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> used to return the current date and time.
+            </para>
+            <para>
+            There are two built strategies for determining the current date and time, 
+            <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>
+            and <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </para>
+            <para>
+            The default strategy is <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">
+            <summary>
+            Gets or sets the date pattern to be used for generating file names
+            when rolling over on date.
+            </summary>
+            <value>
+            The date pattern to be used for generating file names when rolling 
+            over on date.
+            </value>
+            <remarks>
+            <para>
+            Takes a string in the same format as expected by 
+            <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.
+            </para>
+            <para>
+            This property determines the rollover schedule when rolling over
+            on date.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">
+            <summary>
+            Gets or sets the maximum number of backup files that are kept before
+            the oldest is erased.
+            </summary>
+            <value>
+            The maximum number of backup files that are kept before the oldest is
+            erased.
+            </value>
+            <remarks>
+            <para>
+            If set to zero, then there will be no backup files and the log file 
+            will be truncated when it reaches <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  
+            </para>
+            <para>
+            If a negative number is supplied then no deletions will be made.  Note 
+            that this could result in very slow performance as a large number of 
+            files are rolled over unless <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> is used.
+            </para>
+            <para>
+            The maximum applies to <b>each</b> time based group of files and 
+            <b>not</b> the total.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size in bytes that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except
+            that it is required for differentiating the setter taking a
+            <see cref="T:System.Int64"/> argument from the setter taking a <see cref="T:System.String"/> 
+            argument.
+            </para>
+            <para>
+            The default maximum file size is 10MB (10*1024*1024).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property allows you to specify the maximum size with the
+            suffixes "KB", "MB" or "GB" so that the size is interpreted being 
+            expressed respectively in kilobytes, megabytes or gigabytes. 
+            </para>
+            <para>
+            For example, the value "10KB" will be interpreted as 10240 bytes.
+            </para>
+            <para>
+            The default maximum file size is 10MB.
+            </para>
+            <para>
+            If you have the option to set the maximum file size programmatically
+            consider using the <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/> property instead as this
+            allows you to set the size in bytes as a <see cref="T:System.Int64"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">
+            <summary>
+            Gets or sets the rolling file count direction. 
+            </summary>
+            <value>
+            The rolling file count direction.
+            </value>
+            <remarks>
+            <para>
+            Indicates if the current file is the lowest numbered file or the
+            highest numbered file.
+            </para>
+            <para>
+            By default newer files have lower numbers (<see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &lt; 0),
+            i.e. log.1 is most recent, log.5 is the 5th backup, etc...
+            </para>
+            <para>
+            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 does the opposite i.e.
+            log.1 is the first backup made, log.5 is the 5th backup made, etc.
+            For infinite backups use <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 to reduce 
+            rollover costs.
+            </para>
+            <para>The default file count direction is -1.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">
+            <summary>
+            Gets or sets the rolling style.
+            </summary>
+            <value>The rolling style.</value>
+            <remarks>
+            <para>
+            The default rolling style is <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/>.
+            </para>
+            <para>
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> this appender's
+            <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is set to <c>false</c>, otherwise
+            the appender would append to a single file rather than rolling
+            the file each time it is opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.PreserveLogFileNameExtension">
+            <summary>
+            Gets or sets a value indicating whether to preserve the file name extension when rolling.
+            </summary>
+            <value>
+            <c>true</c> if the file name extension should be preserved.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is rolled to file.log.yyyy-MM-dd or file.log.curSizeRollBackup.
+            However, under Windows the new file name will loose any program associations as the
+            extension is changed. Optionally file.log can be renamed to file.yyyy-MM-dd.log or
+            file.curSizeRollBackup.log to maintain any program associations.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">
+            <summary>
+            Gets or sets a value indicating whether to always log to
+            the same file.
+            </summary>
+            <value>
+            <c>true</c> if always should be logged to the same file, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is always the current file.  Optionally
+            file.log.yyyy-mm-dd for current formatted datePattern can by the currently
+            logging file (or file.log.curSizeRollBackup or even
+            file.log.yyyy-mm-dd.curSizeRollBackup).
+            </para>
+            <para>
+            This will make time based rollovers with a large number of backups 
+            much faster as the appender it won't have to rename all the backups!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">
+            <summary>
+            Style of rolling to use
+            </summary>
+            <remarks>
+            <para>
+            Style of rolling to use
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Once">
+            <summary>
+            Roll files once per program execution
+            </summary>
+            <remarks>
+            <para>
+            Roll files once per program execution.
+            Well really once each time this appender is
+            configured.
+            </para>
+            <para>
+            Setting this option also sets <c>AppendToFile</c> to
+            <c>false</c> on the <c>RollingFileAppender</c>, otherwise
+            this appender would just be a normal file appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">
+            <summary>
+            Roll files based only on the size of the file
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">
+            <summary>
+            Roll files based only on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">
+            <summary>
+            Roll files based on both the size and date of the file
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">
+            <summary>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </summary>
+            <remarks>
+            <para>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.InvalidRollPoint">
+            <summary>
+            Roll the log not based on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMinute">
+            <summary>
+            Roll the log for each minute
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfHour">
+            <summary>
+            Roll the log for each hour
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HalfDay">
+            <summary>
+            Roll the log twice a day (midday and midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfDay">
+            <summary>
+            Roll the log each day (midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfWeek">
+            <summary>
+            Roll the log each week
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMonth">
+            <summary>
+            Roll the log each month
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.IDateTime">
+            <summary>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            </summary>
+            <remarks>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            Used primarily to allow test classes to plug themselves in so they can
+            supply test date/times.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.IDateTime.Now">
+            <summary>
+            Gets the <i>current</i> time.
+            </summary>
+            <value>The <i>current</i> time.</value>
+            <remarks>
+            <para>
+            Gets the <i>current</i> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.LocalDateTime">
+            <summary>
+            Default implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.LocalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.UniversalDateTime">
+            <summary>
+            Implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time as the coordinated universal time (UTC).
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.UniversalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender">
+            <summary>
+            Send an e-mail when a specific logging event occurs, typically on errors 
+            or fatal errors.
+            </summary>
+            <remarks>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            <note type="caution">
+            Authentication and setting the server Port are only available on the MS .NET 1.1 runtime.
+            For these features to be enabled you need to ensure that you are using a version of
+            the log4net assembly that is built against the MS .NET 1.1 framework and that you are
+            running the your application on the MS .NET 1.1 runtime. On all other platforms only sending
+            unauthenticated messages to a server listening on port 25 (the default) is supported.
+            </note>
+            <para>
+            Authentication is supported by setting the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property to
+            either <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> or <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>.
+            If using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> authentication then the <see cref="P:log4net.Appender.SmtpAppender.Username"/>
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> properties must also be set.
+            </para>
+            <para>
+            To set the SMTP server port use the <see cref="P:log4net.Appender.SmtpAppender.Port"/> property. The default port is 25.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendEmail(System.String)">
+            <summary>
+            Send the email message
+            </summary>
+            <param name="messageBody">the body text to include in the mail</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.MaybeTrimSeparators(System.String)">
+            <summary>
+              trims leading and trailing commas or semicolons
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.To">
+            <summary>
+            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).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Cc">
+            <summary>
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses 
+            that will be carbon copied (use semicolon on .NET 1.1 and comma for later versions).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Bcc">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses
+            that will be blind carbon copied.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of recipient e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SmtpHost">
+            <summary>
+            Gets or sets the name of the SMTP relay mail server to use to send 
+            the e-mail messages.
+            </summary>
+            <value>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </value>
+            <remarks>
+            <para>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.LocationInfo">
+            <summary>
+            Obsolete
+            </summary>
+            <remarks>
+            Use the BufferingAppenderSkeleton Fix methods instead 
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Authentication">
+            <summary>
+            The mode to use to authentication with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            Valid Authentication mode values are: <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>, 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, and <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>. 
+            The default value is <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>. When using 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> you must specify the <see cref="P:log4net.Appender.SmtpAppender.Username"/> 
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> to use to authenticate.
+            When using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/> the Windows credentials for the current
+            thread, if impersonating, or the process will be used to authenticate. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Username">
+            <summary>
+            The username to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the username will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Password">
+            <summary>
+            The password to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the password will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Port">
+            <summary>
+            The port on which the SMTP server is listening
+            </summary>
+            <remarks>
+            <note type="caution">Server Port is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            The port on which the SMTP server is listening. The default
+            port is <c>25</c>. The Port can only be changed when running on
+            the MS .NET 1.1 runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Priority">
+            <summary>
+            Gets or sets the priority of the e-mail message
+            </summary>
+            <value>
+            One of the <see cref="T:System.Net.Mail.MailPriority"/> values.
+            </value>
+            <remarks>
+            <para>
+            Sets the priority of the e-mails generated by this
+            appender. The default priority is <see cref="F:System.Net.Mail.MailPriority.Normal"/>.
+            </para>
+            <para>
+            If you are using this appender to report errors then
+            you may want to set the priority to <see cref="F:System.Net.Mail.MailPriority.High"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.EnableSsl">
+            <summary>
+            Enable or disable use of SSL when sending e-mail message
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.ReplyTo">
+            <summary>
+            Gets or sets the reply-to e-mail address.
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SubjectEncoding">
+            <summary>
+            Gets or sets the subject encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.BodyEncoding">
+            <summary>
+            Gets or sets the body encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender.SmtpAuthentication">
+            <summary>
+            Values for the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property.
+            </summary>
+            <remarks>
+            <para>
+            SMTP authentication modes.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None">
+            <summary>
+            No authentication
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic">
+            <summary>
+            Basic authentication.
+            </summary>
+            <remarks>
+            Requires a username and password to be supplied
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm">
+            <summary>
+            Integrated authentication
+            </summary>
+            <remarks>
+            Uses the Windows credentials from the current thread or process to authenticate.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpPickupDirAppender">
+            <summary>
+            Send an email when a specific logging event occurs, typically on errors 
+            or fatal errors. Rather than sending via smtp it writes a file into the
+            directory specified by <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>. This allows services such
+            as the IIS SMTP agent to manage sending the messages.
+            </summary>
+            <remarks>
+            <para>
+            The configuration for this appender is identical to that of the <c>SMTPAppender</c>,
+            except that instead of specifying the <c>SMTPAppender.SMTPHost</c> you specify
+            <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>.
+            </para>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpPickupDirAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            </remarks>
+            <author>Niall Daley</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+            <remarks>
+            <para>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions">
+            <summary>
+            Activate the options on this appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpPickupDirAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.To">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.PickupDir">
+            <summary>
+            Gets or sets the path to write the messages to.
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the path to write the messages to. This should be the same
+            as that used by the agent sending the messages.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.FileExtension">
+            <summary>
+            Gets or sets the file extension for the generated files
+            </summary>
+            <value>
+            The file extension for the generated files
+            </value>
+            <remarks>
+            <para>
+            The file extension for the generated files
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender">
+            <summary>
+            Appender that allows clients to connect via Telnet to receive log messages
+            </summary>
+            <remarks>	
+            <para>
+            The TelnetAppender accepts socket connections and streams logging messages
+            back to the client.  
+            The output is provided in a telnet-friendly way so that a log can be monitored 
+            over a TCP/IP socket.
+            This allows simple remote monitoring of application logging.
+            </para>
+            <para>
+            The default <see cref="P:log4net.Appender.TelnetAppender.Port"/> is 23 (the telnet port).
+            </para>
+            </remarks>
+            <author>Keith Long</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TelnetAppender.declaringType">
+            <summary>
+            The fully qualified type of the TelnetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.OnClose">
+            <summary>
+            Overrides the parent method to close the socket handler
+            </summary>
+            <remarks>
+            <para>
+            Closes all the outstanding connections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Create the socket handler and wait for connections
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to each connected client.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to each connected client.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.Port">
+            <summary>
+            Gets or sets the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </value>
+            <remarks>
+            <para>
+            The default value is 23 (the telnet port).
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler">
+            <summary>
+            Helper class to manage connected clients
+            </summary>
+            <remarks>
+            <para>
+            The SocketHandler class is used to accept connections from
+            clients.  It is threaded so that clients can connect/disconnect
+            asynchronously.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.#ctor(System.Int32)">
+            <summary>
+            Opens a new server port on <paramref ref="port"/>
+            </summary>
+            <param name="port">the local port to listen on for connections</param>
+            <remarks>
+            <para>
+            Creates a socket handler on the specified local server port.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Send(System.String)">
+            <summary>
+            Sends a string message to each of the connected clients
+            </summary>
+            <param name="message">the text to send</param>
+            <remarks>
+            <para>
+            Sends a string message to each of the connected clients
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.AddClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Add a client to the internal clients list
+            </summary>
+            <param name="client">client to add</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.RemoveClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Remove a client from the internal clients list
+            </summary>
+            <param name="client">client to remove</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.OnConnect(System.IAsyncResult)">
+            <summary>
+            Callback used to accept a connection on the server socket
+            </summary>
+            <param name="asyncResult">The result of the asynchronous operation</param>
+            <remarks>
+            <para>
+            On connection adds to the list of connections 
+            if there are two many open connections you will be disconnected
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Dispose">
+            <summary>
+            Close all network connections
+            </summary>
+            <remarks>
+            <para>
+            Make sure we close all network connections
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.SocketHandler.HasConnections">
+            <summary>
+            Test if this handler has active connections
+            </summary>
+            <value>
+            <c>true</c> if this handler has active connections
+            </value>
+            <remarks>
+            <para>
+            This property will be <c>true</c> while this handler has
+            active connections, that is at least one connection that 
+            the handler will attempt to send a message to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient">
+            <summary>
+            Class that represents a client connected to this handler
+            </summary>
+            <remarks>
+            <para>
+            Class that represents a client connected to this handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.#ctor(System.Net.Sockets.Socket)">
+            <summary>
+            Create this <see cref="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient"/> for the specified <see cref="T:System.Net.Sockets.Socket"/>
+            </summary>
+            <param name="socket">the client's socket</param>
+            <remarks>
+            <para>
+            Opens a stream writer on the socket.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Send(System.String)">
+            <summary>
+            Write a string to the client
+            </summary>
+            <param name="message">string to send</param>
+            <remarks>
+            <para>
+            Write a string to the client
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Dispose">
+            <summary>
+            Cleanup the clients connection
+            </summary>
+            <remarks>
+            <para>
+            Close the socket connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TraceAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Trace"/> class for details on configuring the
+            trace system.
+            </para>
+            <para>
+            Events are written using the <c>System.Diagnostics.Trace.Write(string,string)</c>
+            method. The event's logger name is the default value for the category parameter 
+            of the Write method. 
+            </para>
+            <para>
+            <b>Compact Framework</b><br/>
+            The Compact Framework does not support the <see cref="T:System.Diagnostics.Trace"/>
+            class for any operation except <c>Assert</c>. When using the Compact Framework this
+            appender will write to the <see cref="T:System.Diagnostics.Debug"/> system rather than
+            the Trace system. This appender will therefore behave like the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </para>
+            </remarks>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.AliasDomainAttribute">
+            <summary>
+            Assembly level attribute that specifies a domain to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.DomainAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's domain to its repository by
+            specifying this attribute with the name of the target domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required domains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.AliasRepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies a repository to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.RepositoryAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's repository to its repository by
+            specifying this attribute with the name of the target repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required repositories.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.AliasRepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </summary>
+            <param name="name">The repository to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.AliasRepositoryAttribute.Name">
+            <summary>
+            Gets or sets the repository to alias to this assemby's repository.
+            </summary>
+            <value>
+            The repository to alias to this assemby's repository.
+            </value>
+            <remarks>
+            <para>
+            The name of the repository to alias to this assemby's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.AliasDomainAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasDomainAttribute"/> class with 
+            the specified domain to alias to this assembly's repository.
+            </summary>
+            <param name="name">The domain to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Obsolete. Use <see cref="T:log4net.Config.AliasRepositoryAttribute"/> instead of <see cref="T:log4net.Config.AliasDomainAttribute"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.BasicConfigurator">
+            <summary>
+            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </summary>
+            <remarks>
+            <para>
+            Allows very simple programmatic configuration of log4net.
+            </para>
+            <para>
+            Only one appender can be configured using this configurator.
+            The appender is set at the root of the hierarchy and all logging
+            events will be delivered to that appender.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Config.BasicConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the BasicConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.BasicConfigurator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure">
+            <summary>
+            Initializes the log4net system with a default configuration.
+            </summary>
+            <remarks>
+            <para>
+            Initializes the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the log4net system using the specified appenders.
+            </summary>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initializes the log4net system using the specified appender.
+            </summary>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> with a default configuration.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Initializes the specified repository using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appenders.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.ConfiguratorAttribute">
+            <summary>
+            Base class for all log4net configuration attributes.
+            </summary>
+            <remarks>
+            This is an abstract class that must be extended by 
+            specific configurators. This attribute allows the
+            configurator to be parameterized by an assembly level
+            attribute.
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">
+            <summary>
+            Constructor used by subclasses.
+            </summary>
+            <param name="priority">the ordering priority for this configurator</param>
+            <remarks>
+            <para>
+            The <paramref name="priority"/> is used to order the configurator
+            attributes before they are invoked. Higher priority configurators are executed
+            before lower priority ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Abstract method implemented by a subclass. When this method is called
+            the subclass should configure the <paramref name="targetRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">
+            <summary>
+            Compare this instance to another ConfiguratorAttribute
+            </summary>
+            <param name="obj">the object to compare to</param>
+            <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>
+            <remarks>
+            <para>
+            Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.
+            Sorts by priority in descending order. Objects with the same priority are
+            randomly ordered.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DomainAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging domain for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            <b>DomainAttribute is obsolete. Use RepositoryAttribute instead of DomainAttribute.</b>
+            </para>
+            <para>
+            Assemblies are mapped to logging domains. Each domain has its own
+            logging repository. This attribute specified on the assembly controls
+            the configuration of the domain. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the repository objects to create for the domain. If 
+            this attribute is not specified and a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> is not specified
+            then the assembly will be part of the default shared logging domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.RepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging repository for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            Assemblies are mapped to logging repository. This attribute specified 
+            on the assembly controls
+            the configuration of the repository. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the repository that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the <see cref="T:log4net.Repository.ILoggerRepository"/> object 
+            to create for the assembly. If this attribute is not specified or a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> 
+            is not specified then the assembly will be part of the default shared logging repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class 
+            with the name of the repository.
+            </summary>
+            <param name="name">The name of the repository.</param>
+            <remarks>
+            <para>
+            Initialize the attribute with the name for the assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.Name">
+            <summary>
+            Gets or sets the name of the logging repository.
+            </summary>
+            <value>
+            The string name to use as the name of the repository associated with this
+            assembly.
+            </value>
+            <remarks>
+            <para>
+            This value does not have to be unique. Several assemblies can share the
+            same repository. They will share the logging configuration of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.RepositoryType">
+            <summary>
+            Gets or sets the type of repository to create for this assembly.
+            </summary>
+            <value>
+            The type of repository to create for this assembly.
+            </value>
+            <remarks>
+            <para>
+            The type of the repository to create for the assembly.
+            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            interface.
+            </para>
+            <para>
+            This will be the type of repository created when 
+            the repository is created. If multiple assemblies reference the
+            same repository then the repository is only created once using the
+            <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/> of the first assembly to call into the 
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class 
+            with the name of the domain.
+            </summary>
+            <param name="name">The name of the domain.</param>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DOMConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="T:log4net.Config.DOMConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.XmlConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            <para>
+            If neither of the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>
+            properties are set the configuration is loaded from the application's .config file.
+            If set the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property takes priority over the
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property. The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property
+            specifies a path to a file to load the config from. The path is relative to the
+            application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property is used as a postfix to the assembly file name.
+            The config file must be located in the  application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            For example in a console application setting the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> to
+            <c>config</c> has the same effect as not specifying the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or 
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> properties.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.Watch"/> property can be set to cause the <see cref="T:log4net.Config.XmlConfigurator"/>
+            to watch the configuration file for changes.
+            </para>
+            <note>
+            <para>
+            Log4net will only look for assembly level configuration attributes once.
+            When using the log4net assembly level attributes to control the configuration 
+            of log4net you must ensure that the first call to any of the 
+            <see cref="T:log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration
+            attributes. 
+            </para>
+            <para>
+            If you cannot guarantee the order in which log4net calls will be made from 
+            different assemblies you must use programmatic configuration instead, i.e.
+            call the <see cref="M:XmlConfigurator.Configure()"/> method directly.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Configure the repository using the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            The <paramref name="targetRepository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>
+            class otherwise the <see cref="T:log4net.Config.XmlConfigurator"/> will not be able to
+            configure it.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="targetRepository"/> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.</exception>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from the local file system
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configure the specified repository using a <see cref="T:System.IO.FileInfo"/>
+            </summary>
+            <param name="targetRepository">The repository to configure.</param>
+            <param name="configFile">the FileInfo pointing to the config file</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromUri(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from a URI
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="F:log4net.Config.XmlConfiguratorAttribute.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfiguratorAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile">
+            <summary>
+            Gets or sets the filename of the configuration file.
+            </summary>
+            <value>
+            The filename of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified, this is the name of the configuration file to use with
+            the <see cref="T:log4net.Config.XmlConfigurator"/>. This file path is relative to the
+            <b>application base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>).
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension">
+            <summary>
+            Gets or sets the extension of the configuration file.
+            </summary>
+            <value>
+            The extension of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified this is the extension for the configuration file.
+            The path to the config file is built by using the <b>application 
+            base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>),
+            the <b>assembly file name</b> and the config file extension.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> is set to <c>MyExt</c> then
+            possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or
+            <c>MyClassLibrary.dll.MyExt</c>.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.Watch">
+            <summary>
+            Gets or sets a value indicating whether to watch the configuration file.
+            </summary>
+            <value>
+            <c>true</c> if the configuration should be watched, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            If this flag is specified and set to <c>true</c> then the framework
+            will watch the configuration file and will reload the config each time 
+            the file is modified.
+            </para>
+            <para>
+            The config file can only be watched if it is loaded from local disk.
+            In a No-Touch (Smart Client) deployment where the application is downloaded
+            from a web server the config file may not reside on the local disk
+            and therefore it may not be able to watch it.
+            </para>
+            <note>
+            Watching configuration is not supported on the SSCLI.
+            </note>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
+            <summary>
+            Class to register for the log4net section of the configuration file
+            </summary>
+            <remarks>
+            The log4net section of the configuration file needs to have a section
+            handler registered. This is the section handler used. It simply returns
+            the XML element that is the root of the section.
+            </remarks>
+            <example>
+            Example of registering the log4net section handler :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<configSections>
+            		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
+            	</configSections>
+            	<log4net>
+            		log4net configuration XML goes here
+            	</log4net>
+            </configuration>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
+            <summary>
+            Parses the configuration section.
+            </summary>
+            <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
+            <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>
+            <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>
+            <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.PluginAttribute">
+            <summary>
+            Assembly level attribute that specifies a plugin to attach to 
+            the repository.
+            </summary>
+            <remarks>
+            <para>
+            Specifies the type of a plugin to create and attach to the
+            assembly's repository. The plugin type must implement the
+            <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Plugin.IPluginFactory">
+            <summary>
+            Interface used to create plugins.
+            </summary>
+            <remarks>
+            <para>
+            Interface used to create  a plugin.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPluginFactory.CreatePlugin">
+            <summary>
+            Creates the plugin object.
+            </summary>
+            <returns>the new plugin instance</returns>
+            <remarks>
+            <para>
+            Create and return a new plugin instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="typeName">The type name of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            <para>
+            Where possible use the constructor that takes a <see cref="T:System.Type"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.Type)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="type">The type of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.CreatePlugin">
+            <summary>
+            Creates the plugin object defined by this attribute.
+            </summary>
+            <remarks>
+            <para>
+            Creates the instance of the <see cref="T:log4net.Plugin.IPlugin"/> object as 
+            specified by this attribute.
+            </para>
+            </remarks>
+            <returns>The plugin object.</returns>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.ToString">
+            <summary>
+            Returns a representation of the properties of this object.
+            </summary>
+            <remarks>
+            <para>
+            Overrides base class <see cref="M:Object.ToString()" /> method to 
+            return a representation of the properties of this object.
+            </para>
+            </remarks>
+            <returns>A representation of the properties of this object</returns>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.Type">
+            <summary>
+            Gets or sets the type for the plugin.
+            </summary>
+            <value>
+            The type for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type for the plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.TypeName">
+            <summary>
+            Gets or sets the type name for the plugin.
+            </summary>
+            <value>
+            The type name for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type name for the plugin.
+            </para>
+            <para>
+            Where possible use the <see cref="P:log4net.Config.PluginAttribute.Type"/> property instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.SecurityContextProviderAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">
+            <summary>
+            Construct provider attribute with type specified
+            </summary>
+            <param name="providerType">the type of the provider to use</param>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the SecurityContextProvider
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.
+            Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.SecurityContextProviderAttribute.declaringType">
+            <summary>
+            The fully qualified type of the SecurityContextProviderAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">
+            <summary>
+            Gets or sets the type of the provider to use.
+            </summary>
+            <value>
+            the type of the provider to use.
+            </value>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Uri)">
+            <summary>
+            Configures log4net using the specified configuration URI.
+            </summary>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration data stream.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Uri)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            URI.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.InternalConfigureFromXml(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the specified repository using a <c>log4net</c> element.
+            </summary>
+            <param name="repository">The hierarchy to configure.</param>
+            <param name="element">The element to parse.</param>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            <para>
+            This method is ultimately called by one of the Configure methods 
+            to load the configuration from an <see cref="T:System.Xml.XmlElement"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.m_repositoryName2ConfigAndWatchHandler">
+            <summary>
+            Maps repository names to ConfigAndWatchHandler instances to allow a particular
+            ConfigAndWatchHandler to dispose of its FileSystemWatcher when a repository is 
+            reconfigured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler">
+            <summary>
+            Class used to watch config files.
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="T:System.IO.FileSystemWatcher"/> to monitor
+            changes to a specified file. Because multiple change notifications
+            may be raised when the file is modified, a timer is used to
+            compress the notifications into a single event. The timer
+            waits for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> time before delivering
+            the event notification. If any further <see cref="T:System.IO.FileSystemWatcher"/>
+            change notifications arrive while the timer is waiting it
+            is reset and waits again for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> to
+            elapse.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis">
+            <summary>
+            The default amount of time to wait after receiving notification
+            before reloading the config file.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_configFile">
+            <summary>
+            Holds the FileInfo used to configure the XmlConfigurator
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_repository">
+            <summary>
+            Holds the repository being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_timer">
+            <summary>
+            The timer used to compress the notification events.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_watcher">
+            <summary>
+            Watches file for changes. This object should be disposed when no longer
+            needed to free system handles on the watched resources.
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class to
+            watch a specified config file used to configure a repository.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The configuration file to watch.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.OnWatchedFileChange(System.Object)">
+            <summary>
+            Called by the timer when the configuration has been updated.
+            </summary>
+            <param name="state">null</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.Dispose">
+            <summary>
+            Release the handles held by the watcher and timer.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.CompactRepositorySelector">
+            <summary>
+            The implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface suitable
+            for use with the compact framework
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.IRepositorySelector"/> implementation is a simple
+            mapping between repository name and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            object.
+            </para>
+            <para>
+            The .NET Compact Framework 1.0 does not support retrieving assembly
+            level attributes therefore unlike the <c>DefaultRepositorySelector</c>
+            this selector does not examine the calling assembly for attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Core.IRepositorySelector">
+            <summary>
+            Interface used by the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.Core.IRepositorySelector"/> 
+            to specify the policy for selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> 
+            to return to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association. The results of this method must be repeatable, i.e.
+            when called again with the same arguments the result must be the
+            save value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the named <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repositoryName">The name to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            Lookup a named <see cref="T:log4net.Repository.ILoggerRepository"/>. This is the repository created by
+            calling <see cref="M:CreateRepository(string,Type)"/>.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="assembly">The assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository with the name specified.
+            </summary>
+            <param name="repositoryName">The name to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the name
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same name will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(Assembly, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(Assembly)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>
+            An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances created by 
+            this <see cref="T:log4net.Core.IRepositorySelector"/>.</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Create a new repository selector
+            </summary>
+            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new compact repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
+            </summary>
+            <param name="assembly">not used</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <param name="repositoryName">the name of the repository to lookup</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>. The default 
+            repository is <c>log4net-default-repository</c>. Other repositories 
+            must be created using the <see cref="M:CreateRepository(string, Type)"/>.
+            If the named repository does not exist an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> does not exist</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="assembly">not used</param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            If the <paramref name="repositoryType"/> is <c>null</c> then the
+            default repository type specified to the constructor is used.
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Create a new repository for the repository specified
+            </summary>
+            <param name="repositoryName">the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is null then the default repository type is used.</param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            <para>
+            If the named repository already exists an exception will be thrown.
+            </para>
+            <para>
+            If <paramref name="repositoryType"/> is <c>null</c> then the default 
+            repository type specified to the constructor is used.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> already exists</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.CompactRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the CompactRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notify the registered listeners that the repository has been created
+            </summary>
+            <param name="repository">The repository that has been created</param>
+            <remarks>
+            <para>
+            Raises the <event cref="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">LoggerRepositoryCreatedEvent</event>
+            event.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.DefaultRepositorySelector">
+            <summary>
+            The default implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Uses attributes defined on the calling assembly to determine how to
+            configure the hierarchy for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Creates a new repository selector.
+            </summary>
+            <param name="defaultRepositoryType">The type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null"/>.</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="repositoryAssembly">The assembly use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <remarks>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and the repository 
+            to create can be overridden by specifying the <see cref="T:log4net.Config.RepositoryAttribute"/> 
+            attribute on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> 
+            implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically configured using 
+            any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
+            the <paramref name="repositoryAssembly"/>.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.</returns>
+            <remarks>
+            <para>
+            Returns the named repository. If <paramref name="repositoryName"/> is <c>null</c>
+            a <see cref="T:System.ArgumentNullException"/> is thrown. If the repository 
+            does not exist a <see cref="T:log4net.Core.LogException"/> is thrown.
+            </para>
+            <para>
+            Use <see cref="M:CreateRepository(string, Type)"/> to create a repository.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> does not exist.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type,System.String,System.Boolean)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryName">The name to assign to the created repository</param>
+            <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is <see langword="null"/> then the default repository type is used.</param>
+            <returns>The new repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.AliasRepository(System.String,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Aliases a repository to an existing repository.
+            </summary>
+            <param name="repositoryAlias">The repository to alias.</param>
+            <param name="repositoryTarget">The repository that the repository is aliased to.</param>
+            <remarks>
+            <para>
+            The repository specified will be aliased to the repository when created. 
+            The repository must not already exist.
+            </para>
+            <para>
+            When the repository is created it must utilize the same repository type as 
+            the repository it is aliased to, otherwise the aliasing will fail.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="repositoryAlias"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repositoryTarget"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notifies the registered listeners that the repository has been created.
+            </summary>
+            <param name="repository">The repository that has been created.</param>
+            <remarks>
+            <para>
+            Raises the <see cref="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">
+            <summary>
+            Gets the repository name and repository type for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly that has a <see cref="T:log4net.Config.RepositoryAttribute"/>.</param>
+            <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>
+            <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>
+            <exception cref="T:System.ArgumentNullException"><paramref name="assembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the repository using information from the assembly.
+            </summary>
+            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>
+            attributes which define the configuration for the repository.</param>
+            <param name="repository">The repository to configure.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadPlugins(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined plugins on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to add the plugins to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadAliases(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined aliases on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to alias to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="F:log4net.Core.DefaultRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the DefaultRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ErrorCode">
+            <summary>
+            Defined error codes that can be passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Values passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.GenericFailure">
+            <summary>
+            A general error
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.WriteFailure">
+            <summary>
+            Error while writing output
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FlushFailure">
+            <summary>
+            Failed to flush file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.CloseFailure">
+            <summary>
+            Failed to close file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FileOpenFailure">
+            <summary>
+            Unable to open output file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.MissingLayout">
+            <summary>
+            No layout specified
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.AddressParseFailure">
+            <summary>
+            Failed to parse address
+            </summary>
+        </member>
+        <member name="T:log4net.Core.ExceptionEvaluator">
+            <summary>
+            An evaluator that triggers on an Exception type
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the type of the Exception
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to a Type in <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.    /// 
+            </para>
+            </remarks>
+            <author>Drew Schaeffer</author>
+        </member>
+        <member name="T:log4net.Core.ITriggeringEventEvaluator">
+            <summary>
+            Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action
+            </summary>
+            <remarks>
+            <para>
+            Implementations of this interface allow certain appenders to decide
+            when to perform an appender specific action.
+            </para>
+            <para>
+            The action or behavior triggered is defined by the implementation.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if this event triggers the action
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
+            <remarks>
+            <para>
+            Return <c>true</c> if this event triggers the action
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_type">
+            <summary>
+            The type that causes the trigger to fire.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_triggerOnSubclass">
+            <summary>
+            Causes subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/> to cause the trigger to fire.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor">
+            <summary>
+            Default ctor to allow dynamic creation through a configurator.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor(System.Type,System.Boolean)">
+            <summary>
+            Constructs an evaluator and initializes to trigger on <paramref name="exType"/>
+            </summary>
+            <param name="exType">the type that triggers this evaluator.</param>
+            <param name="triggerOnSubClass">If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.</param>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the logging event Exception 
+            Type is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the Exception Type of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.ExceptionType">
+            <summary>
+            The type that triggers this evaluator.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.TriggerOnSubclass">
+            <summary>
+            If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.IErrorHandler">
+            <summary>
+            Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.
+            </summary>
+            <remarks>
+            <para>
+            Error handling is a particularly tedious to get right because by
+            definition errors are hard to predict and to reproduce. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <param name="errorCode">The error code associated with the error.</param>
+            <remarks>
+            <para>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IFixingRequired">
+            <summary>
+            Interface for objects that require fixing.
+            </summary>
+            <remarks>
+            <para>
+            Interface that indicates that the object requires fixing before it
+            can be taken outside the context of the appender's 
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            When objects that implement this interface are stored 
+            in the context properties maps <see cref="T:log4net.GlobalContext"/>
+            <see cref="P:log4net.GlobalContext.Properties"/> and <see cref="T:log4net.ThreadContext"/>
+            <see cref="P:log4net.ThreadContext.Properties"/> are fixed 
+            (see <see cref="P:log4net.Core.LoggingEvent.Fix"/>) the <see cref="M:log4net.Core.IFixingRequired.GetFixedObject"/>
+            method will be called.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IFixingRequired.GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a portable instance object that represents the current
+            state of this object. The portable object can be stored
+            and logged from any thread with identical results.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILogger">
+            <summary>
+            Interface that all loggers implement
+            </summary>
+            <remarks>
+            <para>
+            This interface supports logging events and testing if a level
+            is enabled for logging.
+            </para>
+            <para>
+            These methods will not throw exceptions. Note to implementor, ensure
+            that the implementation of these methods cannot allow an exception
+            to be thrown to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">the exception to log, including its stack trace. Pass <c>null</c> to not log an exception.</param>
+            <remarks>
+            <para>
+            Generates a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="T:log4net.Core.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Name">
+            <summary>
+            Gets the name of the logger.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILoggerWrapper">
+            <summary>
+            Base interface for all wrappers
+            </summary>
+            <remarks>
+            <para>
+            Base interface for all wrappers.
+            </para>
+            <para>
+            All wrappers must implement this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Core.ILoggerWrapper.Logger">
+            <summary>
+            Get the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this
+            object. The <c>Logger</c> object may not 
+            be the same object as this object because of logger decorators.
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventHandler">
+            <summary>
+            Delegate used to handle logger repository creation event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Core.IRepositorySelector"/> which created the repository.</param>
+            <param name="e">The <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> event args
+            that holds the <see cref="T:log4net.Repository.ILoggerRepository"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> 
+            event is raised every time a <see cref="T:log4net.Repository.ILoggerRepository"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerRepositoryCreationEventArgs.m_repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggerRepositoryCreationEventArgs.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </summary>
+            <param name="repository">the <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created</param>
+            <remarks>
+            <para>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggerRepositoryCreationEventArgs.LoggerRepository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.Level">
+            <summary>
+            Defines the default set of levels recognized by the system.
+            </summary>
+            <remarks>
+            <para>
+            Each <see cref="T:log4net.Core.LoggingEvent"/> has an associated <see cref="T:log4net.Core.Level"/>.
+            </para>
+            <para>
+            Levels have a numeric <see cref="P:log4net.Core.Level.Value"/> that defines the relative 
+            ordering between levels. Two Levels with the same <see cref="P:log4net.Core.Level.Value"/> 
+            are deemed to be equivalent.
+            </para>
+            <para>
+            The levels that are recognized by log4net are set for each <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and each repository can have different levels defined. The levels are stored
+            in the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> on the repository. Levels are
+            looked up by name from the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>.
+            </para>
+            <para>
+            When logging at level INFO the actual level used is not <see cref="F:log4net.Core.Level.Info"/> but
+            the value of <c>LoggerRepository.LevelMap["INFO"]</c>. The default value for this is
+            <see cref="F:log4net.Core.Level.Info"/>, but this can be changed by reconfiguring the level map.
+            </para>
+            <para>
+            Each level has a <see cref="P:log4net.Core.Level.DisplayName"/> in addition to its <see cref="P:log4net.Core.Level.Name"/>. The 
+            <see cref="P:log4net.Core.Level.DisplayName"/> is the string that is written into the output log. By default
+            the display name is the same as the level name, but this can be used to alias levels
+            or to localize the log output.
+            </para>
+            <para>
+            Some of the predefined levels recognized by the system are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Off"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Fatal"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Error"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Warn"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Info"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Debug"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.All"/>.</description>
+            	</item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <param name="displayName">The display name for this level. This may be localized or otherwise different from the name</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.ToString">
+            <summary>
+            Returns the <see cref="T:System.String"/> representation of the current 
+            <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <returns>
+            A <see cref="T:System.String"/> representation of the current <see cref="T:log4net.Core.Level"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns the level <see cref="P:log4net.Core.Level.Name"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Equals(System.Object)">
+            <summary>
+            Compares levels.
+            </summary>
+            <param name="o">The object to compare against.</param>
+            <returns><c>true</c> if the objects are equal.</returns>
+            <remarks>
+            <para>
+            Compares the levels of <see cref="T:log4net.Core.Level"/> instances, and 
+            defers to base class if the target object is not a <see cref="T:log4net.Core.Level"/>
+            instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.GetHashCode">
+            <summary>
+            Returns a hash code
+            </summary>
+            <returns>A hash code for the current <see cref="T:log4net.Core.Level"/>.</returns>
+            <remarks>
+            <para>
+            Returns a hash code suitable for use in hashing algorithms and data 
+            structures like a hash table.
+            </para>
+            <para>
+            Returns the hash code of the level <see cref="P:log4net.Core.Level.Value"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.CompareTo(System.Object)">
+            <summary>
+            Compares this instance to a specified object and returns an 
+            indication of their relative values.
+            </summary>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> instance or <see langword="null"/> to compare with this instance.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description>This instance is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description>This instance is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description>
+            			<para>This instance is greater than <paramref name="r"/>.</para>
+            			<para>-or-</para>
+            			<para><paramref name="r"/> is <see langword="null"/>.</para>
+            			</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            <paramref name="r"/> must be an instance of <see cref="T:log4net.Core.Level"/> 
+            or <see langword="null"/>; otherwise, an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException"><paramref name="r"/> is not a <see cref="T:log4net.Core.Level"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Equality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have the same value.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is the same as the 
+            value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Inequality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have different values.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is different from
+            the value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Compare(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Compares two specified <see cref="T:log4net.Core.Level"/> instances.
+            </summary>
+            <param name="l">The first <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <param name="r">The second <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            two values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description><paramref name="l"/> is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description><paramref name="l"/> is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description><paramref name="l"/> is greater than <paramref name="r"/>.</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.Level.Off">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Off"/> level designates a higher level than all the rest.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Log4Net_Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Emergency">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fatal">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fatal"/> level designates very severe error events 
+            that will presumably lead the application to abort.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Alert">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Alert"/> level designates very severe error events. 
+            Take immediate action, alerts.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Critical">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Critical"/> level designates very severe error events. 
+            Critical condition, critical.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Severe">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Severe"/> level designates very severe error events.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Error">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Error"/> level designates error events that might 
+            still allow the application to continue running.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Warn">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Warn"/> level designates potentially harmful 
+            situations.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Notice">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Notice"/> level designates informational messages 
+            that highlight the progress of the application at the highest level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Info">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Info"/> level designates informational messages that 
+            highlight the progress of the application at coarse-grained level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Debug"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fine">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fine"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Trace">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Trace"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finer">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finer"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Verbose">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Verbose"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finest">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finest"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.All">
+            <summary>
+            The <see cref="F:log4net.Core.Level.All"/> level designates the lowest level possible.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.Level.Name">
+            <summary>
+            Gets the name of this level.
+            </summary>
+            <value>
+            The name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.Value">
+            <summary>
+            Gets the value of this level.
+            </summary>
+            <value>
+            The value of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the value of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.DisplayName">
+            <summary>
+            Gets the display name of this level.
+            </summary>
+            <value>
+            The display name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the display name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Core.Level"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ReadOnly(log4net.Core.LevelCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>LevelCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>LevelCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>LevelCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <c>LevelCollection</c>.
+            </summary>
+            <param name="c">The <c>LevelCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.Level[])">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Core.Level"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[])">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[],System.Int32)">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Add(log4net.Core.Level)">
+            <summary>
+            Adds a <see cref="T:log4net.Core.Level"/> to the end of the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to be added to the end of the <c>LevelCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clear">
+            <summary>
+            Removes all elements from the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Core.LevelCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Contains(log4net.Core.Level)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Core.Level"/> is in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.IndexOf(log4net.Core.Level)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Core.Level"/>
+            in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to locate in the <c>LevelCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>LevelCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Insert(System.Int32,log4net.Core.Level)">
+            <summary>
+            Inserts an element into the <c>LevelCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Remove(log4net.Core.Level)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Core.Level"/> from the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to remove from the <c>LevelCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Core.Level"/> was not found in the <c>LevelCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>LevelCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>LevelCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Core.LevelCollection.Enumerator"/> for the entire <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.LevelCollection)">
+            <summary>
+            Adds the elements of another <c>LevelCollection</c> to the current <c>LevelCollection</c>.
+            </summary>
+            <param name="x">The <c>LevelCollection</c> whose elements should be added to the end of the current <c>LevelCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.Level[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> array to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> collection to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.Level"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>LevelCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.ILevelCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LevelCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelEvaluator">
+            <summary>
+            An evaluator that triggers at a threshold level
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelEvaluator.m_threshold">
+            <summary>
+            The threshold for triggering
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor(log4net.Core.Level)">
+            <summary>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </summary>
+            <param name="threshold">the threshold to trigger at</param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the event level
+            is equal or higher than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelEvaluator.Threshold">
+            <summary>
+            the threshold to trigger at
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.Level"/> that will cause this evaluator to trigger
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelMap">
+            <summary>
+            Mapping between string name and Level object
+            </summary>
+            <remarks>
+            <para>
+            Mapping between string name and <see cref="T:log4net.Core.Level"/> object.
+            This mapping is held separately for each <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The level name is case insensitive.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelMap.m_mapName2Level">
+            <summary>
+            Mapping from level name to Level object. The
+            level name is case insensitive
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelMap.#ctor">
+            <summary>
+            Construct the level map
+            </summary>
+            <remarks>
+            <para>
+            Construct the level map.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Clear">
+            <summary>
+            Clear the internal maps of all levels
+            </summary>
+            <remarks>
+            <para>
+            Clear the internal maps of all levels
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+            <seealso cref="M:Add(string,int,string)"/>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32,System.String)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <param name="displayName">the display name to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(log4net.Core.Level)">
+            <summary>
+            Add a Level to the map
+            </summary>
+            <param name="level">the Level to add</param>
+            <remarks>
+            <para>
+            Add a Level to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.LookupWithDefault(log4net.Core.Level)">
+            <summary>
+            Lookup a named level from the map
+            </summary>
+            <param name="defaultLevel">the name of the level to lookup is taken from this level. 
+            If the level is not set on the map then this level is added</param>
+            <returns>the level in the map with the name specified</returns>
+            <remarks>
+            <para>
+            Lookup a named level from the map. The name of the level to lookup is taken
+            from the <see cref="P:log4net.Core.Level.Name"/> property of the <paramref name="defaultLevel"/>
+            argument.
+            </para>
+            <para>
+            If no level with the specified name is found then the 
+            <paramref name="defaultLevel"/> argument is added to the level map
+            and returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.Item(System.String)">
+            <summary>
+            Lookup a <see cref="T:log4net.Core.Level"/> by name
+            </summary>
+            <param name="name">The name of the Level to lookup</param>
+            <returns>a Level from the map with the name specified</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:log4net.Core.Level"/> from the
+            map with the name specified. If the no level is
+            found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.AllLevels">
+            <summary>
+            Return all possible levels as a list of Level objects.
+            </summary>
+            <returns>all possible levels as a list of Level objects</returns>
+            <remarks>
+            <para>
+            Return all possible levels as a list of Level objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LocationInfo">
+            <summary>
+            The internal representation of caller location information.
+            </summary>
+            <remarks>
+            <para>
+            This class uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.Type)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class based on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="className">The fully qualified class name.</param>
+            <param name="methodName">The method name.</param>
+            <param name="fileName">The file name.</param>
+            <param name="lineNumber">The line number of the method within the file.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class with the specified data.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.declaringType">
+            <summary>
+            The fully qualified type of the LocationInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.MethodName">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.StackFrames">
+            <summary>
+            Gets the stack frames from the stack trace of the caller making the log request
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LoggerManager">
+            <summary>
+            Static manager that controls the creation of repositories
+            </summary>
+            <remarks>
+            <para>
+            Static manager that controls the creation of repositories
+            </para>
+            <para>
+            This class is used by the wrapper managers (e.g. <see cref="T:log4net.LogManager"/>)
+            to provide access to the <see cref="T:log4net.Core.ILogger"/> objects.
+            </para>
+            <para>
+            This manager also holds the <see cref="T:log4net.Core.IRepositorySelector"/> that is used to
+            lookup and create repositories. The selector can be set either programmatically using
+            the <see cref="P:log4net.Core.LoggerManager.RepositorySelector"/> property, or by setting the <c>log4net.RepositorySelector</c>
+            AppSetting in the applications config file to the fully qualified type name of the
+            selector to use. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#ctor">
+            <summary>
+            Private constructor to prevent instances. Only static methods should be used.
+            </summary>
+            <remarks>
+            <para>
+            Private constructor to prevent instances. Only static methods should be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#cctor">
+            <summary>
+            Hook the shutdown event
+            </summary>
+            <remarks>
+            <para>
+            On the full .NET runtime, the static constructor hooks up the 
+            <c>AppDomain.ProcessExit</c> and <c>AppDomain.DomainUnload</c>> events. 
+            These are used to shutdown the log4net system as the application exits.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.RegisterAppDomainEvents">
+            <summary>
+            Register for ProcessExit and DomainUnload events on the AppDomain
+            </summary>
+            <remarks>
+            <para>
+            This needs to be in a separate method because the events make
+            a LinkDemand for the ControlAppDomain SecurityPermission. Because
+            this is a LinkDemand it is demanded at JIT time. Therefore we cannot
+            catch the exception in the method itself, we have to catch it in the
+            caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified assembly's repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified assembly's repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to lookup the repository</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repository">The repository to shutdown.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repository">The repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+            <remarks>
+            <para>
+            Gets an array of all currently defined repositories.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetVersionInfo">
+            <summary>
+            Internal method to get pertinent version info.
+            </summary>
+            <returns>A string of version info.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnDomainUnload(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnProcessExit(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.declaringType">
+            <summary>
+            The fully qualified type of the LoggerManager class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.s_repositorySelector">
+            <summary>
+            Initialize the default repository selector
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerManager.RepositorySelector">
+            <summary>
+            Gets or sets the repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </summary>
+            <value>
+            The repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </value>
+            <remarks>
+            <para>
+            The repository selector (<see cref="T:log4net.Core.IRepositorySelector"/>) is used by 
+            the <see cref="T:log4net.LogManager"/> to create and select repositories 
+            (<see cref="T:log4net.Repository.ILoggerRepository"/>).
+            </para>
+            <para>
+            The caller to <see cref="T:log4net.LogManager"/> supplies either a string name 
+            or an assembly (if not supplied the assembly is inferred using 
+            <see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            <para>
+            This context is used by the selector to lookup a specific repository.
+            </para>
+            <para>
+            For the full .NET Framework, the default repository is <c>DefaultRepositorySelector</c>;
+            for the .NET Compact Framework <c>CompactRepositorySelector</c> is the default
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerWrapperImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.ILoggerWrapper"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This class should be used as the base for all wrapper implementations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerWrapperImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Constructs a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Constructs a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerWrapperImpl.m_logger">
+            <summary>
+            The logger that this object is wrapping
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerWrapperImpl.Logger">
+            <summary>
+            Gets the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that this object is implementing.
+            </value>
+            <remarks>
+            <para>
+            The <c>Logger</c> object may not be the same object as this object 
+            because of logger decorators.
+            </para>
+            <para>
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEventData">
+            <summary>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LoggerName">
+            <summary>
+            The logger name.
+            </summary>
+            <remarks>
+            <para>
+            The logger name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Level">
+            <summary>
+            Level of logging event.
+            </summary>
+            <remarks>
+            <para>
+            Level of logging event. Level cannot be Serializable
+            because it is a flyweight.  Due to its special serialization it
+            cannot be declared final either.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Message">
+            <summary>
+            The application supplied message.
+            </summary>
+            <remarks>
+            <para>
+            The application supplied message of logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ThreadName">
+            <summary>
+            The name of thread
+            </summary>
+            <remarks>
+            <para>
+            The name of thread in which this logging event was generated
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.TimeStamp">
+            <summary>
+            Gets or sets the local time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            Prefer using the <see cref="P:log4net.Core.LoggingEventData.TimeStampUtc"/> setter, since local time can be ambiguous.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LocationInfo">
+            <summary>
+            Location information for the caller.
+            </summary>
+            <remarks>
+            <para>
+            Location information for the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.UserName">
+            <summary>
+            String representation of the user
+            </summary>
+            <remarks>
+            <para>
+            String representation of the user's windows name,
+            like DOMAIN\username
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Identity">
+            <summary>
+            String representation of the identity.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the current thread's principal identity.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ExceptionString">
+            <summary>
+            The string representation of the exception
+            </summary>
+            <remarks>
+            <para>
+            The string representation of the exception
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Domain">
+            <summary>
+            String representation of the AppDomain.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Properties">
+            <summary>
+            Additional event specific properties
+            </summary>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEventData.TimeStampUtc">
+            <summary>
+            Gets or sets the UTC time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            The TimeStamp is stored in the UTC time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.FixFlags">
+            <summary>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </summary>
+            <remarks>
+            <para>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Mdc">
+            <summary>
+            Fix the MDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Ndc">
+            <summary>
+            Fix the NDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Message">
+            <summary>
+            Fix the rendered message
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.ThreadName">
+            <summary>
+            Fix the thread name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.LocationInfo">
+            <summary>
+            Fix the callers location information
+            </summary>
+            <remarks>
+            CAUTION: Very slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.UserName">
+            <summary>
+            Fix the callers windows user name
+            </summary>
+            <remarks>
+            CAUTION: Slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Domain">
+            <summary>
+            Fix the domain friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Identity">
+            <summary>
+            Fix the callers principal name
+            </summary>
+            <remarks>
+            CAUTION: May be slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Exception">
+            <summary>
+            Fix the exception text
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Properties">
+            <summary>
+            Fix the event properties. Active properties must implement <see cref="T:log4net.Core.IFixingRequired"/> in order to be eligible for fixing.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.None">
+            <summary>
+            No fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.All">
+            <summary>
+            All fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Partial">
+            <summary>
+            Partial fields fixed
+            </summary>
+            <remarks>
+            <para>
+            This set of partial fields gives good performance. The following fields are fixed:
+            </para>
+            <list type="bullet">
+            <item><description><see cref="F:log4net.Core.FixFlags.Message"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.ThreadName"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Exception"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Domain"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Properties"/></description></item>
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEvent">
+            <summary>
+            The internal representation of logging events. 
+            </summary>
+            <remarks>
+            <para>
+            When an affirmative decision is made to log then a 
+            <see cref="T:log4net.Core.LoggingEvent"/> instance is created. This instance 
+            is passed around to the different log4net components.
+            </para>
+            <para>
+            This class is of concern to those wishing to extend log4net.
+            </para>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.HostNameProperty">
+            <summary>
+            The key into the Properties map for the host name value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.IdentityProperty">
+            <summary>
+            The key into the Properties map for the thread identity value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.UserNameProperty">
+            <summary>
+            The key into the Properties map for the user name value.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,System.String,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class
+            from the supplied parameters.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="loggerName">The name of the logger of this event.</param>
+            <param name="level">The level of this event.</param>
+            <param name="message">The message of this event.</param>
+            <param name="exception">The exception for this event.</param>
+            <remarks>
+            <para>
+            Except <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.Core.LoggingEvent.Level"/> and <see cref="P:log4net.Core.LoggingEvent.LoggerName"/>, 
+            all fields of <c>LoggingEvent</c> are filled when actually needed. Call
+            <see cref="M:FixVolatileData()"/> to cache all data locally
+            to prevent inconsistencies.
+            </para>
+            <para>This method is called by the log4net framework
+            to create a logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData,log4net.Core.FixFlags)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            The <paramref name="fixedData"/> parameter should be used to specify which fields in the
+            <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>
+            will be captured from the environment if requested or fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.EnsureRepository(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Ensure that the repository is set.
+            </summary>
+            <param name="repository">the value for the repository</param>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)">
+            <summary>
+            Write the rendered message to a TextWriter
+            </summary>
+            <param name="writer">the writer to write the message to</param>
+            <remarks>
+            <para>
+            Unlike the <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property this method
+            does store the message data in the internal cache. Therefore 
+            if called only once this method should be faster than the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property, however if the message is
+            to be accessed multiple times then the property will be more efficient.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            The data in this event must be fixed before it can be serialized.
+            </para>
+            <para>
+            The <see cref="M:FixVolatileData()"/> method must be called during the
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method call if this event 
+            is to be used outside that method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            <para>
+            Does a <see cref="F:log4net.Core.FixFlags.Partial"/> fix of the data
+            in the logging event before returning the event data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData(log4net.Core.FixFlags)">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionStrRep">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            <b>Obsolete. Use <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> instead.</b>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionString">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData">
+            <summary>
+            Fix instance fields that hold volatile data.
+            </summary>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            Calling <see cref="M:FixVolatileData()"/> is equivalent to
+            calling <see cref="M:FixVolatileData(bool)"/> passing the parameter
+            <c>false</c>.
+            </para>
+            <para>
+            See <see cref="M:FixVolatileData(bool)"/> for more
+            information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)">
+            <summary>
+            Fixes instance fields that hold volatile data.
+            </summary>
+            <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            The <paramref name="fastButLoose"/> param controls the data that
+            is fixed. Some of the data that can be fixed takes a long time to 
+            generate, therefore if you do not require those settings to be fixed
+            they can be ignored by setting the <paramref name="fastButLoose"/> param
+            to <c>true</c>. This setting will ignore the <see cref="P:log4net.Core.LoggingEvent.LocationInformation"/>
+            and <see cref="P:log4net.Core.LoggingEvent.UserName"/> settings.
+            </para>
+            <para>
+            Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all 
+            settings are fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)">
+            <summary>
+            Fix the fields specified by the <see cref="T:log4net.Core.FixFlags"/> parameter
+            </summary>
+            <param name="flags">the fields to fix</param>
+            <remarks>
+            <para>
+            Only fields specified in the <paramref name="flags"/> will be fixed.
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.LookupProperty(System.String)">
+            <summary>
+            Lookup a composite property in this event
+            </summary>
+            <param name="key">the key for the property to lookup</param>
+            <returns>the value for the property</returns>
+            <remarks>
+            <para>
+            This event has composite properties that combine together properties from
+            several different contexts in the following order:
+            <list type="definition">
+            	<item>
+            		<term>this events properties</term>
+            		<description>
+            		This event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            		properties are specific to this event only.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the thread properties</term>
+            		<description>
+            		The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            		thread. These properties are shared by all events logged on this thread.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the global properties</term>
+            		<description>
+            		The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            		properties are shared by all the threads in the AppDomain.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetProperties">
+            <summary>
+            Get all the composite properties in this event
+            </summary>
+            <returns>the <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the properties</returns>
+            <remarks>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/> for details of the composite properties 
+            stored by the event.
+            </para>
+            <para>
+            This method returns a single <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the
+            properties defined for this event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_data">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_compositeProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_eventProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_callerStackBoundaryDeclaringType">
+            <summary>
+            The fully qualified Type of the calling 
+            logger class in the stack frame (i.e. the declaring type of the method).
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_message">
+            <summary>
+            The application supplied message of logging event.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_thrownException">
+            <summary>
+            The exception that was thrown.
+            </summary>
+            <remarks>
+            This is not serialized. The string representation
+            is serialized instead.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_repository">
+            <summary>
+            The repository that generated the logging event
+            </summary>
+            <remarks>
+            This is not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_fixFlags">
+            <summary>
+            The fix state for this event
+            </summary>
+            <remarks>
+            These flags indicate which fields have been fixed.
+            Not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_cacheUpdatable">
+            <summary>
+            Indicated that the internal cache is updateable (ie not fixed)
+            </summary>
+            <remarks>
+            This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler
+            changes in the caching strategy.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTime">
+            <summary>
+            Gets the time when the current process started.
+            </summary>
+            <value>
+            This is the time when this process started.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored internally in UTC and converted to the local time zone for this computer.
+            </para>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTimeUtc">
+            <summary>
+            Gets the UTC time when the current process started.
+            </summary>
+            <value>
+            This is the UTC time when this process started.
+            </value>
+            <remarks>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Level">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStamp">
+            <summary>
+            Gets the time of the logging event.
+            </summary>
+            <value>
+            The time of the logging event.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored in UTC and converted to the local time zone for this computer.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStampUtc">
+            <summary>
+            Gets UTC the time of the logging event.
+            </summary>
+            <value>
+            The UTC time of the logging event.
+            </value>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LoggerName">
+            <summary>
+            Gets the name of the logger that logged the event.
+            </summary>
+            <value>
+            The name of the logger that logged the event.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of the logger that logged the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LocationInformation">
+            <summary>
+            Gets the location information for this logging event.
+            </summary>
+            <value>
+            The location information for this logging event.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Core.LocationInfo"/> class for more information on
+            supported frameworks and the different behavior in Debug and
+            Release builds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.MessageObject">
+            <summary>
+            Gets the message object used to initialize this event.
+            </summary>
+            <value>
+            The message object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the message object used to initialize this event.
+            Note that this event may not have a valid message object.
+            If the event is serialized the message object will not 
+            be transferred. To get the text of the message the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined message object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ExceptionObject">
+            <summary>
+            Gets the exception object used to initialize this event.
+            </summary>
+            <value>
+            The exception object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the exception object used to initialize this event.
+            Note that this event may not have a valid exception object.
+            If the event is serialized the exception object will not 
+            be transferred. To get the text of the exception the
+            <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> method must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined exception object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.RenderedMessage">
+            <summary>
+            Gets the message, rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <value>
+            The message rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ThreadName">
+            <summary>
+            Gets the name of the current thread.  
+            </summary>
+            <value>
+            The name of the current thread, or the thread ID when 
+            the name is not available.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.UserName">
+            <summary>
+            Gets the name of the current user.
+            </summary>
+            <value>
+            The name of the current user, or <c>NOT AVAILABLE</c> when the 
+            underlying runtime has no support for retrieving the name of the 
+            current user.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of
+            the current windows user.
+            </para>
+            <para>
+            To improve performance, we could cache the string representation of 
+            the name, and reuse that as long as the identity stayed constant.  
+            Once the identity changed, we would need to re-assign and re-render 
+            the string.
+            </para>
+            <para>
+            However, the <c>WindowsIdentity.GetCurrent()</c> call seems to 
+            return different objects every time, so the current implementation 
+            doesn't do this type of caching.
+            </para>
+            <para>
+            Timing for these operations:
+            </para>
+            <list type="table">
+              <listheader>
+                <term>Method</term>
+                <description>Results</description>
+              </listheader>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent()</c></term>
+                <description>10000 loops, 00:00:00.2031250 seconds</description>
+              </item>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent().Name</c></term>
+                <description>10000 loops, 00:00:08.0468750 seconds</description>
+              </item>
+            </list>
+            <para>
+            This means we could speed things up almost 40 times by caching the 
+            value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since 
+            this takes (8.04-0.20) = 7.84375 seconds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Identity">
+            <summary>
+            Gets the identity of the current thread principal.
+            </summary>
+            <value>
+            The string name of the identity of the current thread principal.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get
+            the name of the current thread principal.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Domain">
+            <summary>
+            Gets the AppDomain friendly name.
+            </summary>
+            <value>
+            The AppDomain friendly name.
+            </value>
+            <remarks>
+            <para>
+            Gets the AppDomain friendly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Properties">
+            <summary>
+            Additional event specific properties.
+            </summary>
+            <value>
+            Additional event specific properties.
+            </value>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            <para>
+            This property is for events that have been added directly to
+            this event. The aggregate properties (which include these
+            event properties) can be retrieved using <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/>
+            and <see cref="M:log4net.Core.LoggingEvent.GetProperties"/>.
+            </para>
+            <para>
+            Once the properties have been fixed <see cref="P:log4net.Core.LoggingEvent.Fix"/> this property
+            returns the combined cached properties. This ensures that updates to
+            this property are always reflected in the underlying storage. When
+            returning the combined properties there may be more keys in the
+            Dictionary than expected.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Fix">
+            <summary>
+            The fixed fields in this event
+            </summary>
+            <value>
+            The set of fields that are fixed in this event
+            </value>
+            <remarks>
+            <para>
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LogImpl">
+            <summary>
+            Implementation of <see cref="T:log4net.ILog"/> wrapper interface.
+            </summary>
+            <remarks>
+            <para>
+            This implementation of the <see cref="T:log4net.ILog"/> interface
+            forwards to the <see cref="T:log4net.Core.ILogger"/> held by the base class.
+            </para>
+            <para>
+            This logger has methods to allow the caller to log at the following
+            levels:
+            </para>
+            <list type="definition">
+              <item>
+                <term>DEBUG</term>
+                <description>
+                The <see cref="M:Debug(object)"/> and <see cref="M:DebugFormat(string, object[])"/> methods log messages
+                at the <c>DEBUG</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Debug"/>. The <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>INFO</term>
+                <description>
+                The <see cref="M:Info(object)"/> and <see cref="M:InfoFormat(string, object[])"/> methods log messages
+                at the <c>INFO</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Info"/>. The <see cref="P:log4net.Core.LogImpl.IsInfoEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>WARN</term>
+                <description>
+                The <see cref="M:Warn(object)"/> and <see cref="M:WarnFormat(string, object[])"/> methods log messages
+                at the <c>WARN</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Warn"/>. The <see cref="P:log4net.Core.LogImpl.IsWarnEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>ERROR</term>
+                <description>
+                The <see cref="M:Error(object)"/> and <see cref="M:ErrorFormat(string, object[])"/> methods log messages
+                at the <c>ERROR</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Error"/>. The <see cref="P:log4net.Core.LogImpl.IsErrorEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>FATAL</term>
+                <description>
+                The <see cref="M:Fatal(object)"/> and <see cref="M:FatalFormat(string, object[])"/> methods log messages
+                at the <c>FATAL</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Fatal"/>. The <see cref="P:log4net.Core.LogImpl.IsFatalEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+            </list>
+            <para>
+            The values for these levels and their semantic meanings can be changed by 
+            configuring the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ILog">
+            <summary>
+            The ILog interface is use by application to log messages into
+            the log4net framework.
+            </summary>
+            <remarks>
+            <para>
+            Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
+            that implement this interface. The <see cref="M:LogManager.GetLogger(Assembly,Type)"/>
+            static method is used to get logger instances.
+            </para>
+            <para>
+            This class contains methods for logging at different levels and also
+            has properties for determining if those logging levels are
+            enabled in the current configuration.
+            </para>
+            <para>
+            This interface can be implemented in different ways. This documentation
+            specifies reasonable behavior that a caller can expect from the actual
+            implementation, however different implementations reserve the right to
+            do things differently.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <seealso cref="T:log4net.LogManager"/>
+            <seealso cref="M:LogManager.GetLogger(Assembly, Type)"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">
+            <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para> For some ILog interface <c>log</c>, when you write:</para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, string construction and concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed (who isn't), then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
+            the <see cref="M:Debug(object)"/>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log. This is the preferred style of logging.
+            </para>
+            <para>Alternatively if your logger is available statically then the is debug
+            enabled state can be stored in a static variable like this:
+            </para>
+            <code lang="C#">
+            private static readonly bool isDebugEnabled = log.IsDebugEnabled;
+            </code>
+            <para>
+            Then when you come to log you can write:
+            </para>
+            <code lang="C#">
+            if (isDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way the debug enabled state is only queried once
+            when the class is loaded. Using a <c>private static readonly</c>
+            variable is the most efficient because it is a run time constant
+            and can be heavily optimized by the JIT compiler.
+            </para>
+            <para>
+            Of course if you use a static readonly variable to
+            hold the enabled state of the logger then you cannot
+            change the enabled state at runtime to vary the logging
+            that is produced. You have to decide if you need absolute
+            speed or runtime flexibility.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="M:DebugFormat(IFormatProvider, string, object[])"/>
+        </member>
+        <member name="P:log4net.ILog.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="M:InfoFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="M:WarnFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="M:ErrorFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="M:FatalFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Construct a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Construct a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ReloadLevels(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Virtual method called when the configuration of the repository changes
+            </summary>
+            <param name="repository">the repository holding the levels</param>
+            <remarks>
+            <para>
+            Virtual method called when the configuration of the repository changes
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <c>DEBUG</c> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>DEBUG</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> passed
+            as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <c>INFO</c> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level.
+            </summary>
+            <param name="message">the message object to log</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <c>WARN</c> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>WARN</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <c>ERROR</c> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>ERROR</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <c>FATAL</c> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>FATAL</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.LoggerRepositoryConfigurationChanged(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for the <see cref="E:log4net.Repository.ILoggerRepository.ConfigurationChanged"/> event
+            </summary>
+            <param name="sender">the repository</param>
+            <param name="e">Empty</param>
+        </member>
+        <member name="F:log4net.Core.LogImpl.ThisDeclaringType">
+            <summary>
+            The fully qualified name of this declaring type not the type of any subclass.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>DEBUG</c>
+            level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>DEBUG</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para>
+            For some <c>log</c> Logger object, when you write:
+            </para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed, then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled())
+            { 
+             log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <c>IsDebugEnabled</c> and once in
+            the <c>Debug</c>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>INFO</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>INFO</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>WARN</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>WARN</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>ERROR</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>ERROR</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>FATAL</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>FATAL</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="T:log4net.Core.MethodItem">
+            <summary>
+            provides method information without actually referencing a System.Reflection.MethodBase
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.MethodItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor">
+            <summary>
+            constructs a method item for an unknown method.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String)">
+            <summary>
+            constructs a method item from the name of the method.
+            </summary>
+            <param name="name"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String,System.String[])">
+            <summary>
+            constructs a method item from the name of the method and its parameters.
+            </summary>
+            <param name="name"></param>
+            <param name="parameters"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.Reflection.MethodBase)">
+            <summary>
+            constructs a method item from a method base by determining the method name and its parameters.
+            </summary>
+            <param name="methodBase"></param>
+        </member>
+        <member name="F:log4net.Core.MethodItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Name">
+            <summary>
+            Gets the method name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The method name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Parameters">
+            <summary>
+            Gets the method parameters of the caller making
+            the logging request.
+            </summary>
+            <value>
+            The method parameters of the caller making
+            the logging request
+            </value>
+            <remarks>
+            <para>
+            Gets the method parameters of the caller making
+            the logging request.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContext">
+            <summary>
+            A SecurityContext used by log4net when interacting with protected resources
+            </summary>
+            <remarks>
+            <para>
+            A SecurityContext used by log4net when interacting with protected resources
+            for example with operating system services. This can be used to impersonate
+            a principal that has been granted privileges on the system resources.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.SecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns>An <see cref="T:System.IDisposable"/> instance that will
+            revoke the impersonation of this SecurityContext, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Impersonate this security context. Further calls on the current
+            thread should now be made in the security context provided
+            by this object. When the <see cref="T:System.IDisposable"/> result 
+            <see cref="M:System.IDisposable.Dispose"/> method is called the security
+            context of the thread should be reverted to the state it was in
+            before <see cref="M:log4net.Core.SecurityContext.Impersonate(System.Object)"/> was called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContextProvider">
+            <summary>
+            The <see cref="T:log4net.Core.SecurityContextProvider"/> providers default <see cref="T:log4net.Core.SecurityContext"/> instances.
+            </summary>
+            <remarks>
+            <para>
+            A configured component that interacts with potentially protected system
+            resources uses a <see cref="T:log4net.Core.SecurityContext"/> to provide the elevated
+            privileges required. If the <see cref="T:log4net.Core.SecurityContext"/> object has
+            been not been explicitly provided to the component then the component
+            will request one from this <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </para>
+            <para>
+            By default the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is
+            an instance of <see cref="T:log4net.Core.SecurityContextProvider"/> which returns only
+            <see cref="T:log4net.Util.NullSecurityContext"/> objects. This is a reasonable default
+            where the privileges required are not know by the system.
+            </para>
+            <para>
+            This default behavior can be overridden by subclassing the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            and overriding the <see cref="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)"/> method to return
+            the desired <see cref="T:log4net.Core.SecurityContext"/> objects. The default provider
+            can be replaced by programmatically setting the value of the 
+            <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> property.
+            </para>
+            <para>
+            An alternative is to use the <c>log4net.Config.SecurityContextProviderAttribute</c>
+            This attribute can be applied to an assembly in the same way as the
+            <c>log4net.Config.XmlConfiguratorAttribute"</c>. The attribute takes
+            the type to use as the <see cref="T:log4net.Core.SecurityContextProvider"/> as an argument.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.SecurityContextProvider.s_defaultProvider">
+            <summary>
+            The default provider
+            </summary>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.#ctor">
+            <summary>
+            Protected default constructor to allow subclassing
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)">
+            <summary>
+            Create a SecurityContext for a consumer
+            </summary>
+            <param name="consumer">The consumer requesting the SecurityContext</param>
+            <returns>An impersonation context</returns>
+            <remarks>
+            <para>
+            The default implementation is to return a <see cref="T:log4net.Util.NullSecurityContext"/>.
+            </para>
+            <para>
+            Subclasses should override this method to provide their own
+            behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.SecurityContextProvider.DefaultProvider">
+            <summary>
+            Gets or sets the default SecurityContextProvider
+            </summary>
+            <value>
+            The default SecurityContextProvider
+            </value>
+            <remarks>
+            <para>
+            The default provider is used by configured components that
+            require a <see cref="T:log4net.Core.SecurityContext"/> and have not had one
+            given to them.
+            </para>
+            <para>
+            By default this is an instance of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that returns <see cref="T:log4net.Util.NullSecurityContext"/> objects.
+            </para>
+            <para>
+            The default provider can be set programmatically by setting
+            the value of this property to a sub class of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that has the desired behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.StackFrameItem">
+            <summary>
+            provides stack frame information without actually referencing a System.Diagnostics.StackFrame
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.StackFrameItem.#ctor(System.Diagnostics.StackFrame)">
+            <summary>
+            returns a stack frame item from a stack frame. This 
+            </summary>
+            <param name="frame"></param>
+            <returns></returns>
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.Method">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.TimeEvaluator">
+            <summary>
+            An evaluator that triggers after specified number of seconds.
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+            <author>Robert Sevcik</author>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL">
+            <summary>
+            The default time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_interval">
+            <summary>
+            The time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_lastTimeUtc">
+            <summary>
+            The UTC time of last check. This gets updated when the object is created and when the evaluator triggers.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor(System.Int32)">
+            <summary>
+            Create a new evaluator using the specified time threshold in seconds.
+            </summary>
+            <param name="interval">
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.TimeEvaluator.Interval">
+            <summary>
+            The time threshold in seconds to trigger after
+            </summary>
+            <value>
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperCreationHandler">
+            <summary>
+            Delegate used to handle creation of new wrappers.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <remarks>
+            <para>
+            Delegate used to handle creation of new wrappers. This delegate
+            is called from the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method to construct the wrapper for the specified logger.
+            </para>
+            <para>
+            The delegate to use is supplied to the <see cref="T:log4net.Core.WrapperMap"/>
+            constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperMap">
+            <summary>
+            Maps between logger objects and wrapper objects.
+            </summary>
+            <remarks>
+            <para>
+            This class maintains a mapping between <see cref="T:log4net.Core.ILogger"/> objects and
+            <see cref="T:log4net.Core.ILoggerWrapper"/> objects. Use the <see cref="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)"/> method to 
+            lookup the <see cref="T:log4net.Core.ILoggerWrapper"/> for the specified <see cref="T:log4net.Core.ILogger"/>.
+            </para>
+            <para>
+            New wrapper instances are created by the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method. The default behavior is for this method to delegate construction
+            of the wrapper to the <see cref="T:log4net.Core.WrapperCreationHandler"/> delegate supplied
+            to the constructor. This allows specialization of the behavior without
+            requiring subclassing of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.#ctor(log4net.Core.WrapperCreationHandler)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/>
+            </summary>
+            <param name="createWrapperHandler">The handler to use to create the wrapper objects.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/> class with 
+            the specified handler to create the wrapper objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)">
+            <summary>
+            Gets the wrapper object for the specified logger.
+            </summary>
+            <returns>The wrapper object for the specified logger</returns>
+            <remarks>
+            <para>
+            If the logger is null then the corresponding wrapper is null.
+            </para>
+            <para>
+            Looks up the wrapper it it has previously been requested and
+            returns it. If the wrapper has never been requested before then
+            the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/> virtual method is
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)">
+            <summary>
+            Creates the wrapper object for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <returns>The wrapper object for the logger.</returns>
+            <remarks>
+            <para>
+            This implementation uses the <see cref="T:log4net.Core.WrapperCreationHandler"/>
+            passed to the constructor to create the wrapper. This method
+            can be overridden in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.RepositoryShutdown(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Called when a monitored repository shutdown event is received.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down</param>
+            <remarks>
+            <para>
+            This method is called when a <see cref="T:log4net.Repository.ILoggerRepository"/> that this
+            <see cref="T:log4net.Core.WrapperMap"/> is holding loggers for has signaled its shutdown
+            event <see cref="E:log4net.Repository.ILoggerRepository.ShutdownEvent"/>. The default
+            behavior of this method is to release the references to the loggers
+            and their wrappers generated for this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.ILoggerRepository_Shutdown(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for repository shutdown event.
+            </summary>
+            <param name="sender">The sender of the event.</param>
+            <param name="e">The event args.</param>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_repositories">
+            <summary>
+            Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_createWrapperHandler">
+            <summary>
+            The handler to use to create the extension wrapper objects.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_shutdownHandler">
+            <summary>
+            Internal reference to the delegate used to register for repository shutdown events.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.WrapperMap.Repositories">
+            <summary>
+            Gets the map of logger repositories.
+            </summary>
+            <value>
+            Map of logger repositories.
+            </value>
+            <remarks>
+            <para>
+            Gets the hashtable that is keyed on <see cref="T:log4net.Repository.ILoggerRepository"/>. The
+            values are hashtables keyed on <see cref="T:log4net.Core.ILogger"/> with the
+            value being the corresponding <see cref="T:log4net.Core.ILoggerWrapper"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.DateFormatter.IDateFormatter">
+            <summary>
+            Render a <see cref="T:System.DateTime"/> as a string.
+            </summary>
+            <remarks>
+            <para>
+            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
+            instance into a string.
+            </para>
+            <para>
+            The <see cref="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/> method is used to render the
+            date to a text writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the specified date as a string.
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:System.DateTime"/> as a string and write it
+            to the <see cref="T:System.IO.TextWriter"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.AbsoluteTimeDateFormat">
+            <summary>
+            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DateAndTimeDateFormat">
+            <summary>
+            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.Iso8601TimeDateFormat">
+            <summary>
+            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Renders the date into a string. Format is <c>"HH:mm:ss"</c>.
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to render the date
+            into a string using a precision up to the second. This method
+            will be called at most once per second and the result will be
+            reused if it is needed again during the same second.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Renders the date into a string. Format is "HH:mm:ss,fff".
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> method to generate the
+            time string up to the seconds and then appends the current
+            milliseconds. The results from <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> are
+            cached and <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> is called at most once
+            per second.
+            </para>
+            <para>
+            Sub classes should override <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/>
+            rather than <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeToTheSecond">
+            <summary>
+            Last stored time with precision up to the second.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeBuf">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeStrings">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"dd MMM yyyy HH:mm:ss,fff"</c>
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format 
+            <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, 
+            <c>"06 Nov 1994 15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Angelika Schnagl</author>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">
+            <summary>
+            Default constructor.
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats a DateTime in the format <c>"dd MMM yyyy HH:mm:ss"</c>
+            for example, <c>"06 Nov 1994 15:49:37"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_dateTimeFormatInfo">
+            <summary>
+            The format info for the invariant culture.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.Iso8601DateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> as <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> specified as a string: <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats the date specified as a string: <c>"yyyy-MM-dd HH:mm:ss"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.SimpleDateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="T:System.DateTime"/> <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="format">The format string.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> class 
+            with the specified format string.
+            </para>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the date using <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </summary>
+            <param name="dateToFormat">The date to convert to a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the date format string supplied to the constructor to call
+            the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method to format the date.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">
+            <summary>
+            The format string used to format the <see cref="T:System.DateTime"/>.
+            </summary>
+            <remarks>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.DenyAllFilter">
+            <summary>
+            This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>. 
+            </summary>
+            <remarks>
+            <para>
+            You can add this filter to the end of a filter chain to
+            switch from the default "accept all unless instructed otherwise"
+            filtering behavior to a "deny all unless instructed otherwise"
+            behavior.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.FilterSkeleton">
+            <summary>
+            Subclass this type to implement customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should extend this class to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.IFilter">
+            <summary>
+            Implement this interface to provide customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should implement this interface to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the logging event should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The LoggingEvent to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.IFilter.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterSkeleton.m_next">
+            <summary>
+            Points to the next filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
+            <summary>
+            Initialize the filter with the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Typically filter's options become active immediately on set, 
+            however this method must still be called. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            <para>
+            This method is marked <c>abstract</c> and must be implemented
+            in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.FilterSkeleton.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            </summary>
+            <param name="loggingEvent">the LoggingEvent to filter</param>
+            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>
+            <remarks>
+            <para>
+            Ignores the event being logged and just returns
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter
+            chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter
+            should only be used as the last filter in the chain
+            as any further filters will be ignored!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.FilterDecision">
+            <summary>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </summary>
+            <remarks>
+            <para>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Deny">
+            <summary>
+            The log event must be dropped immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Neutral">
+            <summary>
+            This filter is neutral with respect to the log event. 
+            The remaining filters, if any, should be consulted for a final decision.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Accept">
+            <summary>
+            The log event must be logged immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="T:log4net.Filter.LevelMatchFilter">
+            <summary>
+            This is a very simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and
+            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value
+            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.Core.Level"/> of the 
+            <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 
+            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set
+            to <c>true</c>, if it is <c>false</c> then 
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">
+            <summary>
+            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.Accept"/> on a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">
+            <summary>
+            the <see cref="T:log4net.Core.Level"/> to match against
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Tests if the <see cref="T:log4net.Core.Level"/> of the logging event matches that of the filter
+            </summary>
+            <param name="loggingEvent">the event to filter</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the event matches the level of the
+            filter then the result of the function depends on the
+            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then
+            the function will return <see cref="F:log4net.Filter.FilterDecision.Accept"/>, it it is false then it
+            will return <see cref="F:log4net.Filter.FilterDecision.Deny"/>. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">
+            <summary>
+            The <see cref="T:log4net.Core.Level"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            The level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LevelRangeFilter">
+            <summary>
+            This is a simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            that determine the range of priorities that are matched, and
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range
+            of priorities and the <see cref="T:log4net.Core.Level"/> of the <see cref="T:log4net.Core.LoggingEvent"/>, then the 
+            <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"/> 
+            option value is set to <c>true</c>, if it is <c>false</c>
+            then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when matching a <see cref="T:log4net.Core.Level"/>
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">
+            <summary>
+            the minimum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">
+            <summary>
+            the maximum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if the event should be logged.
+            </summary>
+            <param name="loggingEvent">the logging event to check</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the logging event is outside the range
+            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            is returned. If the <see cref="T:log4net.Core.Level"/> is matched then the value of
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">
+            <summary>
+            Set the minimum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The minimum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">
+            <summary>
+            Sets the maximum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The maximum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LoggerMatchFilter">
+            <summary>
+            Simple filter to match a string in the event's logger name.
+            </summary>
+            <remarks>
+            <para>
+            The works very similar to the <see cref="T:log4net.Filter.LevelMatchFilter"/>. It admits two 
+            options <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> and <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>. If the 
+            <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <see cref="T:log4net.Core.LoggingEvent"/> starts 
+            with the value of the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> option, then the 
+            <see cref="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in 
+            case the <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> option value is set to <c>true</c>, 
+            if it is <c>false</c> then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_loggerToMatch">
+            <summary>
+            The logger name string to substring match against the event
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>.
+            If the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> equals the beginning of 
+            the incoming <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> (<see cref="M:String.StartsWith(string)"/>)
+            then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch">
+            <summary>
+            The <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            This filter will attempt to match this value against logger name in
+            the following way. The match will be done against the beginning of the
+            logger name (using <see cref="M:String.StartsWith(string)"/>). The match is
+            case sensitive. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.MdcFilter">
+            <summary>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with layered properties the
+            <see cref="T:log4net.Filter.PropertyFilter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.PropertyFilter">
+            <summary>
+            Simple filter to match a string an event property
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the value for a
+            specific event property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Filter.StringMatchFilter">
+            <summary>
+            Simple filter to match a string in the rendered message
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the rendered message
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">
+            <summary>
+            The string to substring match against the message
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">
+            <summary>
+            A string regex to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">
+            <summary>
+            A regex object to match (generated from m_stringRegexToMatch)
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">
+            <summary>
+            Initialize and precompile the Regex if required
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the message then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">
+            <summary>
+            Sets the static string to match
+            </summary>
+            <remarks>
+            <para>
+            The string that will be substring matched against
+            the rendered message. If the message contains this
+            string then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">
+            <summary>
+            Sets the regular expression to match
+            </summary>
+            <remarks>
+            <para>
+            The regular expression pattern that will be matched against
+            the rendered message. If the message matches this
+            pattern then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.PropertyFilter.m_key">
+            <summary>
+            The key to use to lookup the string from the event properties
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The event property for the <see cref="P:log4net.Filter.PropertyFilter.Key"/> is matched against 
+            the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the property value then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.PropertyFilter.Key">
+            <summary>
+            The key to lookup in the event properties and then match against.
+            </summary>
+            <remarks>
+            <para>
+            The key name to use to lookup in the properties map of the
+            <see cref="T:log4net.Core.LoggingEvent"/>. The match will be performed against 
+            the value of this property if it exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.NdcFilter">
+            <summary>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with named stacks stored in the
+            properties collections the <see cref="T:log4net.Filter.PropertyFilter"/> should 
+            be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.NdcFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Sets the <see cref="P:log4net.Filter.PropertyFilter.Key"/> to <c>"NDC"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AppDomainPatternConverter">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Util.PatternConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            <para>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.#ctor">
+            <summary>
+            Protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternConverter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Evaluate this pattern converter and write the output to a writer.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the appropriate way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next pattern converter in the chains
+            </summary>
+            <param name="patternConverter">the pattern converter that should follow this converter in the chain</param>
+            <returns>the next converter</returns>
+            <remarks>
+            <para>
+            The PatternConverter can merge with its neighbor during this method (or a sub class).
+            Therefore the return value may or may not be the value of the argument passed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the pattern converter to the writer with appropriate formatting
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            This method calls <see cref="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)"/> to allow the subclass to perform
+            appropriate conversion of the pattern converter. If formatting options have
+            been specified via the <see cref="P:log4net.Util.PatternConverter.FormattingInfo"/> then this method will
+            apply those formattings before writing the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SpacePad(System.IO.TextWriter,System.Int32)">
+            <summary>
+            Fast space padding method.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> to which the spaces will be appended.</param>
+            <param name="length">The number of spaces to be padded.</param>
+            <remarks>
+            <para>
+            Fast space padding method.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.m_option">
+            <summary>
+            The option string to the converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionary)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionary"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionaryEnumerator)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionaryEnumerator"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteObject(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Object)">
+            <summary>
+            Write an object to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the Object to a writer. If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the object to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Next">
+            <summary>
+            Get the next pattern converter in the chain
+            </summary>
+            <value>
+            the next pattern converter in the chain
+            </value>
+            <remarks>
+            <para>
+            Get the next pattern converter in the chain
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.FormattingInfo">
+            <summary>
+            Gets or sets the formatting info for this converter
+            </summary>
+            <value>
+            The formatting info for this converter
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the formatting info for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Option">
+            <summary>
+            Gets or sets the option value for this converter
+            </summary>
+            <summary>
+            The option for this converter
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the option value for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+        </member>
+        <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">
+            <summary>
+            Flag indicating if this converter handles exceptions
+            </summary>
+            <remarks>
+            <c>false</c> if this converter handles exceptions
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">
+            <summary>
+            Flag indicating if this converter handles the logging event exception
+            </summary>
+            <value><c>false</c> if this converter handles the logging event exception</value>
+            <remarks>
+            <para>
+            If this converter handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the property should be set to <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this converter does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AppDomainPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetCachePatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetPatternLayoutConverter">
+            <summary>
+            Abstract class that provides access to the current HttpContext (<see cref="P:System.Web.HttpContext.Current"/>) that 
+            derived classes need.
+            </summary>
+            <remarks>
+            This class handles the case when HttpContext.Current is null by writing
+            <see cref="P:log4net.Util.SystemInfo.NotAvailableText"/> to the writer.
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetPatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetCachePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Cache will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetContextPatternConverter">
+            <summary>
+            Converter for items in the <see cref="T:System.Web.HttpContext"/>.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="T:System.Web.HttpContext"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetContextPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net HttpContext item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetRequestPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetRequestPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetSessionPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetSessionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Session will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.DatePatternConverter">
+            <summary>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <remarks>
+            <para>
+            Render the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,yyyy"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Layout.Pattern.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter pattern based on the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ExceptionPatternConverter">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception or the exception property specified
+            by the Option value does not exist then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            <para>
+            Recognized values for the Option parameter are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>Message</description>
+            	</item>
+            	<item>
+            		<description>Source</description>
+            	</item>
+            	<item>
+            		<description>StackTrace</description>
+            	</item>
+            	<item>
+            		<description>TargetSite</description>
+            	</item>
+            	<item>
+            		<description>HelpLink</description>
+            	</item>		
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FileLocationPatternConverter">
+            <summary>
+            Writes the caller location file name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FileLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location file name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FullLocationPatternConverter">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FullLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.IdentityPatternConverter">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.IdentityPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <paramref name="loggingEvent"/> 
+            <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LevelPatternConverter">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LineLocationPatternConverter">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LineLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LoggerPatternConverter">
+            <summary>
+            Converter for logger name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NamedPatternConverter">
+            <summary>
+            Converter to output and truncate <c>'.'</c> separated strings
+            </summary>
+            <remarks>
+            <para>
+            This abstract class supports truncating a <c>'.'</c> separated string
+            to show a specified number of elements from the right hand side.
+            This is used to truncate class names that are fully qualified.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> method to
+            return the fully qualified string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Get the fully qualified string data
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>the fully qualified name</returns>
+            <remarks>
+            <para>
+            Overridden by subclasses to get the fully qualified name before the
+            precision is applied to it.
+            </para>
+            <para>
+            Return the fully qualified <c>'.'</c> (dot/period) separated string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> to the precision
+            specified by the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.NamedPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the NamedPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LoggerPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the logger
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified logger name</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MessagePatternConverter">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MethodLocationPatternConverter">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MethodLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NdcPatternConverter">
+            <summary>
+            Converter to include event NDC
+            </summary>
+            <remarks>
+            <para>
+            Outputs the value of the event property named <c>NDC</c>.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NdcPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event NDC to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            As the thread context stacks are now stored in named event properties
+            this converter simply looks up the value of the <c>NDC</c> property.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PropertyPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">
+            <summary>
+            Converter to output the relative time of the event
+            </summary>
+            <remarks>
+            <para>
+            Converter to output the time of the event relative to the start of the program.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the relative time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the relative time of the event in milliseconds.
+            That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>
+            and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
+            <summary>
+            Helper method to get the time difference between two DateTime objects
+            </summary>
+            <param name="start">start time (in the current local time zone)</param>
+            <param name="end">end time (in the current local time zone)</param>
+            <returns>the time difference in milliseconds</returns>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTraceDetailPatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            </para>
+            </remarks>
+            <author>Adam Davies</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTracePatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            </para>
+            </remarks>
+            <author>Michael Cromwell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the strack frames to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.GetMethodInformation(log4net.Core.MethodItem)">
+            <summary>
+            Returns the Name of the method
+            </summary>
+            <param name="method"></param>
+            <remarks>This method was created, so this class could be used as a base class for StackTraceDetailPatternConverter</remarks>
+            <returns>string</returns>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTracePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTracePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTraceDetailPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTraceDetailPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ThreadPatternConverter">
+            <summary>
+            Converter to include event thread name
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ThreadPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the ThreadName to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.TypeNamePatternConverter">
+            <summary>
+            Pattern converter for the class name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.TypeNamePatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the class
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified type name for the caller location</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UserNamePatternConverter">
+            <summary>
+            Converter to include event user name
+            </summary>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UserNamePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UtcDatePatternConverter">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            Uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> 
+            in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.Pattern.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UtcDatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted
+            to Universal time before it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Layout.Pattern.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.DynamicPatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string that re-evaluates on each call.
+            </summary>
+            <remarks>
+            <para>This class is built on <see cref="T:log4net.Layout.PatternLayout"></see> and provides all the
+            features and capabilities of PatternLayout.  PatternLayout is a 'static' class
+            in that its layout is done once at configuration time.  This class will recreate
+            the layout on each reference.</para>
+            <para>One important difference between PatternLayout and DynamicPatternLayout is the
+            treatment of the Header and Footer parameters in the configuration.  The Header and Footer
+            parameters for DynamicPatternLayout must be syntactically in the form of a PatternString,
+            but should not be marked as type log4net.Util.PatternString.  Doing so causes the
+            pattern to be statically converted at configuration time and causes DynamicPatternLayout
+            to perform the same as PatternLayout.</para>
+            <para>Please see <see cref="T:log4net.Layout.PatternLayout"/> for complete documentation.</para>
+            <example>
+            &lt;layout type="log4net.Layout.DynamicPatternLayout"&gt;
+              &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;
+              &lt;param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;
+            &lt;/layout&gt;
+            </example>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.PatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string.
+            </summary>
+            <remarks>
+            <para>
+            The goal of this class is to <see cref="M:PatternLayout.Format(TextWriter,LoggingEvent)"/> a 
+            <see cref="T:log4net.Core.LoggingEvent"/> as a string. The results
+            depend on the <i>conversion pattern</i>.
+            </para>
+            <para>
+            The conversion pattern is closely related to the conversion
+            pattern of the printf function in C. A conversion pattern is
+            composed of literal text and format control expressions called
+            <i>conversion specifiers</i>.
+            </para>
+            <para>
+            <i>You are free to insert any literal text within the conversion
+            pattern.</i>
+            </para>
+            <para>
+            Each conversion specifier starts with a percent sign (%) and is
+            followed by optional <i>format modifiers</i> and a <i>conversion
+            pattern name</i>. The conversion pattern name specifies the type of
+            data, e.g. logger, level, date, thread name. The format
+            modifiers control such things as field width, padding, left and
+            right justification. The following is a simple example.
+            </para>
+            <para>
+            Let the conversion pattern be <b>"%-5level [%thread]: %message%newline"</b> and assume
+            that the log4net environment was set to use a PatternLayout. Then the
+            statements
+            </para>
+            <code lang="C#">
+            ILog log = LogManager.GetLogger(typeof(TestApp));
+            log.Debug("Message 1");
+            log.Warn("Message 2");   
+            </code>
+            <para>would yield the output</para>
+            <code>
+            DEBUG [main]: Message 1
+            WARN  [main]: Message 2  
+            </code>
+            <para>
+            Note that there is no explicit separator between text and
+            conversion specifiers. The pattern parser knows when it has reached
+            the end of a conversion specifier when it reads a conversion
+            character. In the example above the conversion specifier
+            <b>%-5level</b> means the level of the logging event should be left
+            justified to a width of five characters.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>a</term>
+                    <description>Equivalent to <b>appdomain</b></description>
+                </item>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+            			Used to output the friendly name of the AppDomain where the 
+            			logging event was generated. 
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-cache</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-context</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-request</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-session</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>c</term>
+                    <description>Equivalent to <b>logger</b></description>
+                </item>
+                <item>
+                    <term>C</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>class</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>d</term>
+                    <description>Equivalent to <b>date</b></description>
+                </item>
+                <item>
+            		<term>date</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>exception</term>
+            		<description>
+            			<para>
+            			Used to output the exception passed in with the log message.
+            			</para>
+            			<para>
+            			If an exception object is stored in the logging event
+            			it will be rendered into the pattern output with a
+            			trailing newline.
+            			If there is no exception then nothing will be output
+            			and no trailing newline will be appended.
+            			It is typical to put a newline before the exception
+            			and to have the exception as the last data in the pattern.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>F</term>
+                    <description>Equivalent to <b>file</b></description>
+                </item>
+            	<item>
+            		<term>file</term>
+            		<description>
+            			<para>
+            			Used to output the file name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>identity</term>
+            		<description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>l</term>
+                    <description>Equivalent to <b>location</b></description>
+                </item>
+                <item>
+                    <term>L</term>
+                    <description>Equivalent to <b>line</b></description>
+                </item>
+            	<item>
+            		<term>location</term>
+            		<description>
+            			<para>
+            			Used to output location information of the caller which generated
+            			the logging event.
+            			</para>
+            			<para>
+            			The location information depends on the CLI implementation but
+            			usually consists of the fully qualified name of the calling
+            			method followed by the callers source the file name and line
+            			number between parentheses.
+            			</para>
+            			<para>
+            			The location information can be very useful. However, its
+            			generation is <b>extremely</b> slow. Its use should be avoided
+            			unless execution speed is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>level</term>
+            		<description>
+            			<para>
+            			Used to output the level of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>line</term>
+            		<description>
+            			<para>
+            			Used to output the line number from where the logging request
+            			was issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>logger</term>
+                    <description>
+                        <para>
+            			Used to output the logger of the logging event. The
+            			logger conversion specifier can be optionally followed by
+            			<i>precision specifier</i>, that is a decimal constant in
+            			brackets.
+                        </para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the logger name will be
+            			printed. By default the logger name is printed in full.
+            			</para>
+            			<para>
+            			For example, for the logger name "a.b.c" the pattern
+            			<b>%logger{2}</b> will output "b.c".
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>m</term>
+                    <description>Equivalent to <b>message</b></description>
+                </item>
+                <item>
+                    <term>M</term>
+                    <description>Equivalent to <b>method</b></description>
+                </item>
+            	<item>
+            		<term>message</term>
+            		<description>
+            			<para>
+            			Used to output the application supplied message associated with 
+            			the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>mdc</term>
+            		<description>
+            			<para>
+            			The MDC (old name for the ThreadContext.Properties) is now part of the
+            			combined event properties. This pattern is supported for compatibility
+            			but is equivalent to <b>property</b>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>method</term>
+            		<description>
+            			<para>
+            			Used to output the method name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>n</term>
+                    <description>Equivalent to <b>newline</b></description>
+                </item>
+            	<item>
+            		<term>newline</term>
+            		<description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+            		</description>
+            	</item>
+            	<item>
+            		<term>ndc</term>
+            		<description>
+            			<para>
+            			Used to output the NDC (nested diagnostic context) associated
+            			with the thread that generated the logging event.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>p</term>
+                    <description>Equivalent to <b>level</b></description>
+                </item>
+                <item>
+                    <term>P</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+                <item>
+                    <term>properties</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+            	<item>
+            		<term>property</term>
+            		<description>
+            			<para>
+            			Used to output the an event specific property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are added to events by loggers or appenders. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the event properties</term>
+            					<description>
+            					The event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            					properties are specific to this event only.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+            			
+            		</description>
+            	</item>
+                <item>
+                    <term>r</term>
+                    <description>Equivalent to <b>timestamp</b></description>
+                </item>
+            	<item>
+            		<term>stacktrace</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktrace{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+            			type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>stacktracedetail</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktracedetail{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+                        type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+                <item>
+                    <term>t</term>
+                    <description>Equivalent to <b>thread</b></description>
+                </item>
+            	<item>
+            		<term>timestamp</term>
+            		<description>
+            			<para>
+            			Used to output the number of milliseconds elapsed since the start
+            			of the application until the creation of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>thread</term>
+            		<description>
+            			<para>
+            			Used to output the name of the thread that generated the
+            			logging event. Uses the thread number if no name is available.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>type</term> 
+            		<description>
+            			<para>
+            			Used to output the fully qualified type name of the caller
+            			issuing the logging request. This conversion specifier
+            			can be optionally followed by <i>precision specifier</i>, that
+            			is a decimal constant in brackets.
+            			</para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the class name will be
+            			printed. By default the class name is output in fully qualified form.
+            			</para>
+            			<para>
+            			For example, for the class name "log4net.Layout.PatternLayout", the
+            			pattern <b>%type{1}</b> will output "PatternLayout".
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating the caller class information is
+            			slow. Thus, its use should be avoided unless execution speed is
+            			not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+                </item>
+                <item>
+                    <term>u</term>
+                    <description>Equivalent to <b>identity</b></description>
+                </item>
+            	<item>
+            		<term>username</term>
+            		<description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller WindowsIdentity information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>utcdate</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>w</term>
+                    <description>Equivalent to <b>username</b></description>
+                </item>
+                <item>
+                    <term>x</term>
+                    <description>Equivalent to <b>ndc</b></description>
+                </item>
+                <item>
+                    <term>X</term>
+                    <description>Equivalent to <b>mdc</b></description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            The single letter patterns are deprecated in favor of the 
+            longer more descriptive pattern names.
+            </para>
+            <para>
+            By default the relevant information is output as is. However,
+            with the aid of format modifiers it is possible to change the
+            minimum field width, the maximum field width and justification.
+            </para>
+            <para>
+            The optional format modifier is placed between the percent sign
+            and the conversion pattern name.
+            </para>
+            <para>
+            The first optional format modifier is the <i>left justification
+            flag</i> which is just the minus (-) character. Then comes the
+            optional <i>minimum field width</i> modifier. This is a decimal
+            constant that represents the minimum number of characters to
+            output. If the data item requires fewer characters, it is padded on
+            either the left or the right until the minimum width is
+            reached. The default is to pad on the left (right justify) but you
+            can specify right padding with the left justification flag. The
+            padding character is space. If the data item is larger than the
+            minimum field width, the field is expanded to accommodate the
+            data. The value is never truncated.
+            </para>
+            <para>
+            This behavior can be changed using the <i>maximum field
+            width</i> modifier which is designated by a period followed by a
+            decimal constant. If the data item is longer than the maximum
+            field, then the extra characters are removed from the
+            <i>beginning</i> of the data item and not from the end. For
+            example, it the maximum field width is eight and the data item is
+            ten characters long, then the first two characters of the data item
+            are dropped. This behavior deviates from the printf function in C
+            where truncation is done from the end.
+            </para>
+            <para>
+            Below are various format modifier examples for the logger
+            conversion specifier.
+            </para>
+            <div class="tablediv">
+            	<table class="dtTABLE" cellspacing="0">
+            		<tr>
+            			<th>Format modifier</th>
+            			<th>left justify</th>
+            			<th>minimum width</th>
+            			<th>maximum width</th>
+            			<th>comment</th>
+            		</tr>
+            		<tr>
+            			<td align="center">%20logger</td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is less than 20
+            				characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger 
+            				name is less than 20 characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%.30logger</td>
+            			<td align="center">NA</td>
+            			<td align="center">none</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Truncate from the beginning if the logger 
+            				name is longer than 30 characters.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center"><nobr>%20.30logger</nobr></td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20.30logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            	</table>
+            </div>
+            <para>
+            <b>Note about caller location information.</b><br/>
+            The following patterns <c>%type %file %line %method %location %class %C %F %L %l %M</c> 
+            all generate caller location information.
+            Location information uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            </note>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </note>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Layout.PatternLayout"/>
+            instance using the <see cref="M:AddConverter(string, Type)"/> method.
+            </para>
+            </remarks>
+            <example>
+            This is a more detailed pattern.
+            <code><b>%timestamp [%thread] %level %logger %ndc - %message%newline</b></code>
+            </example>
+            <example>
+            A similar pattern except that the relative time is
+            right padded if less than 6 digits, thread name is right padded if
+            less than 15 characters and truncated if longer and the logger
+            name is left padded if shorter than 30 characters and truncated if
+            longer.
+            <code><b>%-6timestamp [%15.15thread] %-5level %30.30logger %ndc - %message%newline</b></code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="T:log4net.Layout.LayoutSkeleton">
+            <summary>
+            Extend this abstract class to create your own log layout format.
+            </summary>
+            <remarks>
+            <para>
+            This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
+            interface. Most layout objects should extend this class.
+            </para>
+            </remarks>
+            <remarks>
+            <note type="inheritinfo">
+            <para>
+            Subclasses must implement the <see cref="M:Format(TextWriter,LoggingEvent)"/>
+            method.
+            </para>
+            <para>
+            Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default
+            constructor.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.ILayout">
+            <summary>
+            Interface implemented by layout objects
+            </summary>
+            <remarks>
+            <para>
+            An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            as text. The <see cref="M:Format(TextWriter,LoggingEvent)"/> method is called by an
+            appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.
+            </para>
+            <para>
+            The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            text that is appender before any events and after all the events respectively.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text and output to a writer.
+            </para>
+            <para>
+            If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the
+            event to be formatted as a <see cref="T:System.String"/> then the following
+            code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.
+            </para>
+            <code lang="C#">
+            StringWriter writer = new StringWriter();
+            Layout.Format(writer, loggingEvent);
+            string formattedEvent = writer.ToString();
+            </code>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type</value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This is a MIME type e.g. <c>"text/plain"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.IgnoresException">
+            <summary>
+            Flag indicating if this layout handle exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_header">
+            <summary>
+            The header text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
+            <summary>
+            The footer text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <remarks>
+            <para>
+            <c>false</c> if this layout handles exceptions
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
+            <summary>
+            Empty default constructor
+            </summary>
+            <remarks>
+            <para>
+            Empty default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This method must be implemented by the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Convenience method for easily formatting the logging event into a string variable.
+            </summary>
+            <param name="loggingEvent"></param>
+            <remarks>
+            Creates a new StringWriter instance to store the formatted logging event.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type is <c>"text/plain"</c></value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This base class uses the value <c>"text/plain"</c>.
+            To change this value a subclass must override this
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this layout does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DefaultConversionPattern">
+            <summary>
+            Default pattern string for log output. 
+            </summary>
+            <remarks>
+            <para>
+            Default pattern string for log output. 
+            Currently set to the string <b>"%message%newline"</b> 
+            which just prints the application supplied message. 
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DetailConversionPattern">
+            <summary>
+            A detailed conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            A conversion pattern which includes Time, Thread, Logger, and Nested Context.
+            Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+            <remarks>
+            <para>
+            This static map is overridden by the m_converterRegistry instance map
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternLayout only
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+            <remarks>
+            <para>
+            Defines the builtin global rules.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor">
+            <summary>
+            Constructs a PatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            As per the <see cref="T:log4net.Core.IOptionHandler"/> contract the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>
+            method must be called after the properties on this object have been
+            configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a PatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            When using this constructor the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method 
+            need not be called. This may not be the case when using a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">
+            <summary>
+            Create the pattern parser instance
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/> that will format the event</returns>
+            <remarks>
+            <para>
+            Creates the <see cref="T:log4net.Util.PatternParser"/> used to parse the conversion string. Sets the
+            global and instance rules on the <see cref="T:log4net.Util.PatternParser"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Parse the <see cref="T:log4net.Core.LoggingEvent"/> using the patter format
+            specified in the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a named pattern converter to this instance. This
+            converter will be used in the formatting of the event.
+            This method must be called before <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>.
+            </para>
+            <para>
+            The <paramref name="type"/> specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">
+            <summary>
+            The pattern formatting string
+            </summary>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_headerPatternString">
+            <summary>
+            The header PatternString
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_footerPatternString">
+            <summary>
+            The footer PatternString
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor">
+            <summary>
+            Constructs a DynamicPatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a DynamicPatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.ExceptionLayout">
+            <summary>
+            A Layout that renders only the Exception text from the logging event
+            </summary>
+            <remarks>
+            <para>
+            A Layout that renders only the Exception text from the logging event.
+            </para>
+            <para>
+            This Layout should only be used with appenders that utilize multiple
+            layouts (e.g. <see cref="T:log4net.Appender.AdoNetAppender"/>).
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Constructs a ExceptionLayout
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            Part of the <see cref="T:log4net.Core.IOptionHandler"/> component activation
+            framework.
+            </para>
+            <para>
+            This method does nothing as options become effective immediately.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the exception text from the logging event
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Write the exception string to the <see cref="T:System.IO.TextWriter"/>.
+            The exception string is retrieved from <see cref="M:LoggingEvent.GetExceptionString()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.IRawLayout">
+            <summary>
+            Interface for raw layout objects
+            </summary>
+            <remarks>
+            <para>
+            Interface used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            to an object.
+            </para>
+            <para>
+            This interface should not be confused with the
+            <see cref="T:log4net.Layout.ILayout"/> interface. This interface is used in
+            only certain specialized situations where a raw object is
+            required rather than a formatted string. The <see cref="T:log4net.Layout.ILayout"/>
+            is not generally useful than this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.IRawLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Implement this method to create your own layout format.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Layout2RawLayoutAdapter">
+            <summary>
+            Adapts any <see cref="T:log4net.Layout.ILayout"/> to a <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <remarks>
+            <para>
+            Where an <see cref="T:log4net.Layout.IRawLayout"/> is required this adapter
+            allows a <see cref="T:log4net.Layout.ILayout"/> to be specified.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Layout.Layout2RawLayoutAdapter.m_layout">
+            <summary>
+            The layout to adapt
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Construct a new adapter
+            </summary>
+            <param name="layout">the layout to adapt</param>
+            <remarks>
+            <para>
+            Create the adapter for the specified <paramref name="layout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Format the logging event as an object.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Format the logging event as an object.
+            </para>
+            <para>
+            Uses the <see cref="T:log4net.Layout.ILayout"/> object supplied to 
+            the constructor to perform the formatting.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawLayoutConverter">
+            <summary>
+            Type converter for the <see cref="T:log4net.Layout.IRawLayout"/> interface
+            </summary>
+            <remarks>
+            <para>
+            Used to convert objects to the <see cref="T:log4net.Layout.IRawLayout"/> interface.
+            Supports converting from the <see cref="T:log4net.Layout.ILayout"/> interface to
+            the <see cref="T:log4net.Layout.IRawLayout"/> interface using the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertFrom">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from arbitrary types
+            to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to the
+            type supported by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> to the type supported
+            by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the sourceType be converted to an <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <param name="sourceType">the source to be to be converted</param>
+            <returns><c>true</c> if the source type can be converted to <see cref="T:log4net.Layout.IRawLayout"/></returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to a
+            <see cref="T:log4net.Layout.IRawLayout"/>. Only <see cref="T:log4net.Layout.ILayout"/> is supported
+            as the <paramref name="sourceType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the value to a <see cref="T:log4net.Layout.IRawLayout"/> object
+            </summary>
+            <param name="source">the value to convert</param>
+            <returns>the <see cref="T:log4net.Layout.IRawLayout"/> object</returns>
+            <remarks>
+            <para>
+            Convert the <paramref name="source"/> object to a 
+            <see cref="T:log4net.Layout.IRawLayout"/> object. If the <paramref name="source"/> object
+            is a <see cref="T:log4net.Layout.ILayout"/> then the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>
+            is used to adapt between the two interfaces, otherwise an
+            exception is thrown.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawPropertyLayout">
+            <summary>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.#ctor">
+            <summary>
+            Constructs a RawPropertyLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Lookup the property for <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns property value</returns>
+            <remarks>
+            <para>
+            Looks up and returns the object value of the property
+            named <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>. If there is no property defined
+            with than name then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.RawPropertyLayout.Key">
+            <summary>
+            The name of the value to lookup in the LoggingEvent Properties collection.
+            </summary>
+            <value>
+            Value to lookup in the LoggingEvent Properties collection
+            </value>
+            <remarks>
+            <para>
+            String name of the property to lookup in the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in local time. To format the time stamp
+            in universal time use <see cref="T:log4net.Layout.RawUtcTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawUtcTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawUtcTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in universal time. To format the time stamp
+            in local time use <see cref="T:log4net.Layout.RawTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.SimpleLayout">
+            <summary>
+            A very simple layout
+            </summary>
+            <remarks>
+            <para>
+            SimpleLayout consists of the level of the log statement,
+            followed by " - " and then the log message itself. For example,
+            <code>
+            DEBUG - Hello world
+            </code>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.#ctor">
+            <summary>
+            Constructs a SimpleLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a simple formatted output.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Formats the event as the level of the even,
+            followed by " - " and then the log message itself. The
+            output is terminated by a newline.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayout">
+             <summary>
+             Layout that formats the log events as XML elements.
+             </summary>
+             <remarks>
+             <para>
+             The output of the <see cref="T:log4net.Layout.XmlLayout"/> consists of a series of 
+             log4net:event elements. It does not output a complete well-formed XML 
+             file. The output is designed to be included as an <em>external entity</em>
+             in a separate file to form a correct XML file.
+             </para>
+             <para>
+             For example, if <c>abc</c> is the name of the file where
+             the <see cref="T:log4net.Layout.XmlLayout"/> output goes, then a well-formed XML file would 
+             be:
+             </para>
+             <code lang="XML">
+             &lt;?xml version="1.0" ?&gt;
+             
+             &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;
+            
+             &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;
+                 &amp;data;
+             &lt;/log4net:events&gt;
+             </code>
+             <para>
+             This approach enforces the independence of the <see cref="T:log4net.Layout.XmlLayout"/> 
+             and the appender where it is embedded.
+             </para>
+             <para>
+             The <c>version</c> attribute helps components to correctly
+             interpret output generated by <see cref="T:log4net.Layout.XmlLayout"/>. The value of 
+             this attribute should be "1.2" for release 1.2 and later.
+             </para>
+             <para>
+             Alternatively the <c>Header</c> and <c>Footer</c> properties can be
+             configured to output the correct XML header, open tag and close tag.
+             When setting the <c>Header</c> and <c>Footer</c> properties it is essential
+             that the underlying data store not be appendable otherwise the data
+             will become invalid XML.
+             </para>
+             </remarks>
+             <author>Nicko Cadell</author>
+             <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutBase">
+            <summary>
+            Layout that formats the log events as XML elements.
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract class that must be subclassed by an implementation 
+            to conform to a specific schema.
+            </para>
+            <para>
+            Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class
+            with no location info.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="locationInfo" /> parameter determines whether 
+            location information will be output by the layout. If 
+            <paramref name="locationInfo" /> is set to <c>true</c>, then the 
+            file name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the
+            <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed 
+            to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the
+            <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to format
+            the <see cref="T:log4net.Core.LoggingEvent"/> as XML.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">
+            <summary>
+            Flag to indicate if location information should be included in
+            the XML events.
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">
+            <summary>
+            The string to replace invalid chars with
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">
+            <summary>
+            Gets a value indicating whether to include location information in 
+            the XML events.
+            </summary>
+            <value>
+            <c>true</c> if location information should be included in the XML 
+            events; otherwise, <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file 
+            name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an <c>SMTPAppender</c>
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">
+            <summary>
+            The string to replace characters that can not be expressed in XML with.
+            <remarks>
+            <para>
+            Not all characters may be expressed in XML. This property contains the
+            string to replace those that can not with. This defaults to a ?. Set it
+            to the empty string to simply remove offending characters. For more
+            details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets
+            Character replacement will occur in  the log message, the property names 
+            and the property values.
+            </para>
+            </remarks>
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.ContentType">
+            <summary>
+            Gets the content type output by this layout. 
+            </summary>
+            <value>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </value>
+            <remarks>
+            <para>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor">
+            <summary>
+            Constructs an XmlLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XmlLayout.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SmtpAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Builds a cache of the element names
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Override the base class <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method
+            to write the <see cref="T:log4net.Core.LoggingEvent"/> to the <see cref="T:System.Xml.XmlWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayout.m_prefix">
+            <summary>
+            The prefix to use for all generated element names
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Prefix">
+            <summary>
+            The prefix to use for all element names
+            </summary>
+            <remarks>
+            <para>
+            The default prefix is <b>log4net</b>. Set this property
+            to change the prefix. If the prefix is set to an empty string
+            then no prefix will be written.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeMessage">
+            <summary>
+            Set whether or not to base64 encode the message.
+            </summary>
+            <remarks>
+            <para>
+            By default the log message will be written as text to the xml
+            output. This can cause problems when the message contains binary
+            data. By setting this to true the contents of the message will be
+            base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the log message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeProperties">
+            <summary>
+            Set whether or not to base64 encode the property values.
+            </summary>
+            <remarks>
+            <para>
+            By default the properties will be written as text to the xml
+            output. This can cause problems when one or more properties contain
+            binary data. By setting this to true the values of the properties
+            will be base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the property values.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutSchemaLog4j">
+            <summary>
+            Layout that formats the log events as XML elements compatible with the log4j schema
+            </summary>
+            <remarks>
+            <para>
+            Formats the log events according to the http://logging.apache.org/log4j schema.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutSchemaLog4j.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Actually do the writing of the xml
+            </summary>
+            <param name="writer">the writer to use</param>
+            <param name="loggingEvent">the event to write</param>
+            <remarks>
+            <para>
+            Generate XML that is compatible with the log4j schema.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutSchemaLog4j.Version">
+            <summary>
+            The version of the log4j schema to use.
+            </summary>
+            <remarks>
+            <para>
+            Only version 1.2 of the log4j schema is supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.DefaultRenderer">
+            <summary>
+            The default object Renderer.
+            </summary>
+            <remarks>
+            <para>
+            The default renderer supports rendering objects and collections to strings.
+            </para>
+            <para>
+            See the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)"/> method for details of the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ObjectRenderer.IObjectRenderer">
+            <summary>
+            Implement this interface in order to render objects as strings
+            </summary>
+            <remarks>
+            <para>
+            Certain types require special case conversion to
+            string form. This conversion is done by an object renderer.
+            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>
+            interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.IObjectRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a 
+            string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object, TextWriter)"/>
+            method can be used to render these objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)"/>
+            method can be used to render these objects.
+            </para>
+            <para>
+            The default renderer supports rendering objects to strings as follows:
+            </para>
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Rendered String</description>
+            	</listheader>
+            	<item>
+            		<term><c>null</c></term>
+            		<description>
+            		<para>"(null)"</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Array"/></term>
+            		<description>
+            		<para>
+            		For a one dimensional array this is the
+            		array type name, an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace. 
+            		</para>
+            		<para>
+            		For example: <c>int[] {1, 2, 3}</c>.
+            		</para>
+            		<para>
+            		If the array is not one dimensional the 
+            		<c>Array.ToString()</c> is returned.
+            		</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Collections.IEnumerable"/>, <see cref="T:System.Collections.ICollection"/> &amp; <see cref="T:System.Collections.IEnumerator"/></term>
+            		<description>
+            		<para>
+            		Rendered as an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace.
+            		</para>
+            		<para>
+            		For example: <c>{a, b, c}</c>.
+            		</para>
+            		<para>
+            		All collection classes that implement <see cref="T:System.Collections.ICollection"/> its subclasses, 
+            		or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable"/> interface.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term><see cref="T:System.Collections.DictionaryEntry"/></term>
+            		<description>
+            		<para>
+            		Rendered as the key, an equals sign ('='), and the value (using the appropriate
+            		renderer). 
+            		</para>
+            		<para>
+            		For example: <c>key=value</c>.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term>other</term>
+            		<description>
+            		<para><c>Object.ToString()</c></para>
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array,System.IO.TextWriter)">
+            <summary>
+            Render the array argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="array">the array to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            For a one dimensional array this is the
+            array type name, an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>int[] {1, 2, 3}</c>.
+            </para>
+            <para>
+            If the array is not one dimensional the 
+            <c>Array.ToString()</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderEnumerator(log4net.ObjectRenderer.RendererMap,System.Collections.IEnumerator,System.IO.TextWriter)">
+            <summary>
+            Render the enumerator argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="enumerator">the enumerator to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Rendered as an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>{a, b, c}</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderDictionaryEntry(log4net.ObjectRenderer.RendererMap,System.Collections.DictionaryEntry,System.IO.TextWriter)">
+            <summary>
+            Render the DictionaryEntry argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="entry">the DictionaryEntry to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the key, an equals sign ('='), and the value (using the appropriate
+            renderer). For example: <c>key=value</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.RendererMap">
+            <summary>
+            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a mapping between types that require special
+            rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that
+            is used to render them.
+            </para>
+            <para>
+            The <see cref="M:FindAndRender(object)"/> method is used to render an
+            <c>object</c> using the appropriate renderers defined in this map.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <returns>the object rendered as a string</returns>
+            <remarks>
+            <para>
+            This is a convenience method used to render an object to a string.
+            The alternative method <see cref="M:FindAndRender(object,TextWriter)"/>
+            should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Find the appropriate renderer for the type of the
+            <paramref name="obj"/> parameter. This is accomplished by calling the
+            <see cref="M:Get(Type)"/> method. Once a renderer is found, it is
+            applied on the object <paramref name="obj"/> and the result is returned
+            as a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
+            <summary>
+            Gets the renderer for the specified object type
+            </summary>
+            <param name="obj">the object to lookup the renderer for</param>
+            <returns>the renderer for <paramref name="obj"/></returns>
+            <remarks>
+            <param>
+            Gets the renderer for the specified object type.
+            </param>
+            <param>
+            Syntactic sugar method that calls <see cref="M:Get(Type)"/> 
+            with the type of the object parameter.
+            </param>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
+            <summary>
+            Gets the renderer for the specified type
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+            <remarks>
+            <para>
+            Returns the renderer for the specified type.
+            If no specific renderer has been defined the
+            <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">
+            <summary>
+            Internal function to recursively search interfaces
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
+            <summary>
+            Clear the map of renderers
+            </summary>
+            <remarks>
+            <para>
+            Clear the custom renderers defined by using
+            <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>
+            cannot be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>. 
+            </summary>
+            <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>
+            <param name="renderer">the renderer for <paramref name="typeToRender"/></param>
+            <remarks>
+            <para>
+            Register an object renderer for a specific source type.
+            This renderer will be returned from a call to <see cref="M:Get(Type)"/>
+            specifying the same <paramref name="typeToRender"/> as an argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
+            <summary>
+            Get the default renderer instance
+            </summary>
+            <value>the default renderer</value>
+            <remarks>
+            <para>
+            Get the default renderer
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.IPlugin">
+            <summary>
+            Interface implemented by logger repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            Plugins define additional behavior that can be associated
+            with a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The <see cref="T:log4net.Plugin.PluginMap"/> held by the <see cref="P:log4net.Repository.ILoggerRepository.PluginMap"/>
+            property is used to store the plugins for a repository.
+            </para>
+            <para>
+            The <c>log4net.Config.PluginAttribute</c> can be used to
+            attach plugins to repositories created using configuration
+            attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches the plugin to the specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.IPlugin.Name">
+            <summary>
+            Gets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ReadOnly(log4net.Plugin.PluginCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>PluginCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>PluginCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>PluginCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <c>PluginCollection</c>.
+            </summary>
+            <param name="c">The <c>PluginCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.IPlugin[])">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[])">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[],System.Int32)">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the end of the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to be added to the end of the <c>PluginCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clear">
+            <summary>
+            Removes all elements from the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Plugin.PluginCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Contains(log4net.Plugin.IPlugin)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Plugin.IPlugin"/> is in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>PluginCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IndexOf(log4net.Plugin.IPlugin)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Plugin.IPlugin"/>
+            in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to locate in the <c>PluginCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>PluginCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Insert(System.Int32,log4net.Plugin.IPlugin)">
+            <summary>
+            Inserts an element into the <c>PluginCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Plugin.IPlugin"/> from the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the <c>PluginCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Plugin.IPlugin"/> was not found in the <c>PluginCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>PluginCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>PluginCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Plugin.PluginCollection.Enumerator"/> for the entire <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.PluginCollection)">
+            <summary>
+            Adds the elements of another <c>PluginCollection</c> to the current <c>PluginCollection</c>.
+            </summary>
+            <param name="x">The <c>PluginCollection</c> whose elements should be added to the end of the current <c>PluginCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.IPlugin[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> array to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> collection to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the collection.
+            </value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </value>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value><c>true</c> if the collection has a fixed size; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value><c>true</c> if the collection is read-only; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>PluginCollection</c> can contain.
+            </summary>
+            <value>
+            The number of elements the <c>PluginCollection</c> can contain.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Plugin.PluginCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+            <value>
+            The current element in the collection.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.ReadOnlyPluginCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Plugin.PluginMap">
+            <summary>
+            Map of repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            This class is a name keyed map of the plugins that are
+            attached to a repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository that the plugins should be attached to.</param>
+            <remarks>
+            <para>
+            Initialize a new instance of the <see cref="T:log4net.Plugin.PluginMap"/> class with a 
+            repository that the plugins should be attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to add to the map.</param>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Plugin.IPlugin"/> will be attached to the repository when added.
+            </para>
+            <para>
+            If there already exists a plugin with the same name 
+            attached to the repository then the old plugin will
+            be <see cref="M:log4net.Plugin.IPlugin.Shutdown"/> and replaced with
+            the new plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes a <see cref="T:log4net.Plugin.IPlugin"/> from the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the map.</param>
+            <remarks>
+            <para>
+            Remove a specific plugin from this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.Item(System.String)">
+            <summary>
+            Gets a <see cref="T:log4net.Plugin.IPlugin"/> by name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Plugin.IPlugin"/> to lookup.</param>
+            <returns>
+            The <see cref="T:log4net.Plugin.IPlugin"/> from the map with the name specified, or 
+            <c>null</c> if no plugin is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup a plugin by name. If the plugin is not found <c>null</c>
+            will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.AllPlugins">
+            <summary>
+            Gets all possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <value>All possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.</value>
+            <remarks>
+            <para>
+            Get a collection of all the plugins defined in this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginSkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Plugin.IPlugin"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Plugin.IPlugin"/>
+            interface. This base class can be used by implementors
+            of the <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="name">the name of the plugin</param>
+            <remarks>
+            Initializes a new Plugin with the specified name.
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_name">
+            <summary>
+            The name of this plugin.
+            </summary>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_repository">
+            <summary>
+            The repository this plugin is attached to.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.Name">
+            <summary>
+            Gets or sets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            <para>
+            The name of the plugin must not change one the 
+            plugin has been attached to a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.LoggerRepository">
+            <summary>
+            The repository for this plugin
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is attached to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is 
+            attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin">
+            <summary>
+            Plugin that listens for events from the <see cref="T:log4net.Appender.RemotingAppender"/>
+            </summary>
+            <remarks>
+            <para>
+            This plugin publishes an instance of <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/> 
+            on a specified <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/>. This listens for logging events delivered from
+            a remote <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            <para>
+            When an event is received it is relogged within the attached repository
+            as if it had been raised locally.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class.
+            </para>
+            <para>
+            The <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> property must be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor(System.String)">
+            <summary>
+            Construct with sink Uri.
+            </summary>
+            <param name="sinkUri">The name to publish the sink under in the remoting infrastructure. 
+            See <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> for more details.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class
+            with specified name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            When the plugin is shutdown the remote logging
+            sink is disconnected.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.declaringType">
+            <summary>
+            The fully qualified type of the RemoteLoggingServerPlugin class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri">
+            <summary>
+            Gets or sets the URI of this sink.
+            </summary>
+            <value>
+            The URI of this sink.
+            </value>
+            <remarks>
+            <para>
+            This is the name under which the object is marshaled.
+            <see cref="M:RemotingServices.Marshal(MarshalByRefObject,String,Type)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl">
+            <summary>
+            Delivers <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to listen for logging events
+            and deliver them to the local repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository to log to.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl"/> for the
+            specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Logs the events to the repository.
+            </summary>
+            <param name="events">The events to log.</param>
+            <remarks>
+            <para>
+            The events passed are logged to the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.InitializeLifetimeService">
+            <summary>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance.
+            </summary>
+            <returns><c>null</c> to indicate that this instance should live forever.</returns>
+            <remarks>
+            <para>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance. This object should live forever
+            therefore this implementation returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.m_repository">
+            <summary>
+            The underlying <see cref="T:log4net.Repository.ILoggerRepository"/> that events should
+            be logged to.
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">
+            <summary>
+            Default implementation of <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            </summary>
+            <remarks>
+            <para>
+            This default implementation of the <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            interface is used to create the default subclass
+            of the <see cref="T:log4net.Repository.Hierarchy.Logger"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">
+            <summary>
+            Interface abstracts creation of <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances
+            </summary>
+            <remarks>
+            <para>
+            This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to 
+            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.
+            </para>
+            <para>
+            The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)"/> method is called
+            to create a named <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            <para>
+            Implement this interface to create new subclasses of <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl">
+            <summary>
+            Default internal subclass of <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            </summary>
+            <remarks>
+            <para>
+            This subclass has no additional behavior over the
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> class but does allow instances
+            to be created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Logger">
+            <summary>
+            Implementation of <see cref="T:log4net.Core.ILogger"/> used by <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to provide implementation of <see cref="T:log4net.Core.ILogger"/>
+            interface. Applications should use <see cref="T:log4net.LogManager"/> to get
+            logger instances.
+            </para>
+            <para>
+            This is one of the central classes in the log4net implementation. One of the
+            distinctive features of log4net are hierarchical loggers and their
+            evaluation. The <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> organizes the <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            instances into a rooted tree hierarchy.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.Logger"/> class is abstract. Only concrete subclasses of
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> can be created. The <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            is used to create instances of this type for the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">
+            <summary>
+            This constructor created a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance and
+            sets its name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <remarks>
+            <para>
+            This constructor is protected and designed to be used by
+            a subclass that is not abstract.
+            </para>
+            <para>
+            Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> 
+            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default
+            logger creator.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </summary>
+            <param name="newAppender">An appender to add to this logger</param>
+            <remarks>
+            <para>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </para>
+            <para>
+            If <paramref name="newAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">
+            <summary>
+            Look for the appender named as <c>name</c>
+            </summary>
+            <param name="name">The name of the appender to lookup</param>
+            <returns>The appender with the name specified, or <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Returns the named appender, or null if the appender is not found.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">
+            <summary>
+            Remove all previously added appenders from this Logger instance.
+            </summary>
+            <remarks>
+            <para>
+            Remove all previously added appenders from this Logger instance.
+            </para>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the named appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Deliver the <see cref="T:log4net.Core.LoggingEvent"/> to the attached appenders.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Call the appenders in the hierarchy starting at
+            <c>this</c>. If no appenders could be found, emit a
+            warning.
+            </para>
+            <para>
+            This method calls all the appenders inherited from the
+            hierarchy circumventing any evaluation of whether to log or not
+            to log the particular log request.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">
+            <summary>
+            Closes all attached appenders implementing the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Used to ensure that the appenders are correctly shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This is the most generic printing method. This generic form is intended to be used by wrappers
+            </summary>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generates a logging event and delivers it to the attached
+            appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.Core.LoggingEvent)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">
+            <summary>
+            The name of this logger.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">
+            <summary>
+            The assigned level of this logger. 
+            </summary>
+            <remarks>
+            <para>
+            The <c>level</c> variable need not be 
+            assigned a value in which case it is inherited 
+            form the hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">
+            <summary>
+            The parent of this logger.
+            </summary>
+            <remarks>
+            <para>
+            The parent of this logger. 
+            All loggers have at least one ancestor which is the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">
+            <summary>
+            Loggers need to know what Hierarchy they are in.
+            </summary>
+            <remarks>
+            <para>
+            Loggers need to know what Hierarchy they are in.
+            The hierarchy that this logger is a member of is stored
+            here.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderAttachedImpl">
+            <summary>
+            Helper implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">
+            <summary>
+            Flag indicating if child loggers inherit their parents appenders
+            </summary>
+            <remarks>
+            <para>
+            Additivity is set to true by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderLock">
+            <summary>
+            Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl
+            </summary>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">
+            <summary>
+            Gets or sets the parent logger in the hierarchy.
+            </summary>
+            <value>
+            The parent logger in the hierarchy.
+            </value>
+            <remarks>
+            <para>
+            Part of the Composite pattern that makes the hierarchy.
+            The hierarchy is parent linked rather than child linked.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">
+            <summary>
+            Gets or sets a value indicating if child loggers inherit their parent's appenders.
+            </summary>
+            <value>
+            <c>true</c> if child loggers inherit their parent's appenders.
+            </value>
+            <remarks>
+            <para>
+            Additivity is set to <c>true</c> by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.EffectiveLevel">
+            <summary>
+            Gets the effective level for this logger.
+            </summary>
+            <returns>The nearest level in the logger hierarchy.</returns>
+            <remarks>
+            <para>
+            Starting from this logger, searches the logger hierarchy for a
+            non-null level and returns it. Otherwise, returns the level of the
+            root logger.
+            </para>
+            <para>The Logger class is designed so that this method executes as
+            quickly as possible.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>The hierarchy that this logger belongs to.</value>
+            <remarks>
+            <para>
+            This logger must be attached to a single <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.
+            </value>
+            <remarks>
+            <para>
+            The assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> can be <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Appenders">
+            <summary>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <returns>A collection of the appenders in this logger</returns>
+            <remarks>
+            <para>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>. If no appenders 
+            can be found, then a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Name">
+            <summary>
+            Gets the logger name.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl.#ctor(System.String)">
+            <summary>
+            Construct a new Logger
+            </summary>
+            <param name="name">the name of the logger</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl"/> class
+            with the specified name. 
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
+            <summary>
+            Delegate used to handle logger creation event notifications.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> in which the <see cref="T:log4net.Repository.Hierarchy.Logger"/> has been created.</param>
+            <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args that hold the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a
+            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
+            <summary>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument 
+            class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
+            <summary>
+            Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy">
+            <summary>
+            Hierarchical organization of loggers
+            </summary>
+            <remarks>
+            <para>
+            <i>The casual user should not have to deal with this class
+            directly.</i>
+            </para>
+            <para>
+            This class is specialized in retrieving loggers by name and
+            also maintaining the logger hierarchy. Implements the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            The structure of the logger hierarchy is maintained by the
+            <see cref="M:GetLogger(string)"/> method. The hierarchy is such that children
+            link to their parent but parents do not have any references to their
+            children. Moreover, loggers can be instantiated in any order, in
+            particular descendant before ancestor.
+            </para>
+            <para>
+            In case a descendant is created before a particular ancestor,
+            then it creates a provision node for the ancestor and adds itself
+            to the provision node. Other descendants of the same ancestor add
+            themselves to the previously created provision node.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositorySkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.ILoggerRepository">
+            <summary>
+            Interface implemented by logger repositories.
+            </summary>
+            <remarks>
+            <para>
+            This interface is implemented by logger repositories. e.g. 
+            <see cref="N:log4net.Repository.Hierarchy"/>.
+            </para>
+            <para>
+            This interface is used by the <see cref="T:log4net.LogManager"/>
+            to obtain <see cref="T:log4net.ILog"/> interfaces.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
+            <summary>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If the names logger exists it is returned, otherwise
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers as an Array.
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
+            <summary>
+            Returns a named logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Returns a named logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
+            <summary>Shutdown the repository</summary>
+            <remarks>
+            <para>
+            Shutting down a repository will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <see cref="M:Shutdown()"/> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.ConfigurationMessages">
+            <summary>
+            Collection of internal messages captured during the most 
+            recent configuration process.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            <para>
+            These properties can be specified on a repository specific basis.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes the repository with default (empty) properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct the repository using specific properties
+            </summary>
+            <param name="properties">the properties to set for this repository</param>
+            <remarks>
+            <para>
+            Initializes the repository with specified properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
+            <summary>
+            Test if logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the repository
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the repository as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Return a new logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
+            <summary>
+            Shutdown the repository
+            </summary>
+            <remarks>
+            <para>
+            Shutdown the repository. Can be overridden in a subclass.
+            This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>
+            listeners and all attached plugins of the shutdown event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.LoggerRepositorySkeleton.declaringType">
+            <summary>
+            The fully qualified type of the LoggerRepositorySkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Adds an object renderer for a specific class. 
+            </summary>
+            <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>
+            <param name="rendererInstance">The object renderer used to render the object.</param>
+            <remarks>
+            <para>
+            Adds an object renderer for a specific class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository is shutting down
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository is shutting down.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration reset
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has been reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration changed
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">
+            <summary>
+            Raise a configuration changed event on this repository
+            </summary>
+            <param name="e">EventArgs.Empty</param>
+            <remarks>
+            <para>
+            Applications that programmatically change the configuration of the repository should
+            raise this event notification to notify listeners.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes all configured Appenders that implement <see cref="T:log4net.Appender.IFlushable"/>.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed,
+            or <see cref="F:System.Threading.Timeout.Infinite"/> to wait indefinitely.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The string name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of this repository. The name is
+            used to store and lookup the repositories 
+            stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.ConfigurationMessages">
+            <summary>
+            Contains a list of internal messages captures during the 
+            last configuration.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            These properties can be specified on a repository specific basis
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
+            <summary>
+            Basic Configurator interface for repositories
+            </summary>
+            <remarks>
+            <para>
+            Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>
+            with a default <see cref="T:log4net.Appender.IAppender"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the repository using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the repository using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IXmlRepositoryConfigurator">
+            <summary>
+            Configure repository using XML
+            </summary>
+            <remarks>
+            <para>
+            Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the repository using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            The schema for the XML configuration data is defined by
+            the implementation.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct with properties
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with a logger factory
+            </summary>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with properties and a logger factory
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
+            <summary>
+            Test if a logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the hierarchy. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the hierarchy as an Array
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the hierarchy as an Array.
+            The root logger is <b>not</b> included in the returned
+            enumeration.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </summary>
+            <remarks>
+            <para>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
+            <summary>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </summary>
+            <remarks>
+            <para>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <c>Shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
+            <summary>
+            Reset all values contained in this hierarchy instance to their default.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this hierarchy instance to their
+            default.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this hierarchy.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">
+            <summary>
+            Returns all the Appenders that are currently configured
+            </summary>
+            <returns>An array containing all the currently configured appenders</returns>
+            <remarks>
+            <para>
+            Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.
+            All the loggers are searched for appenders. The appenders may also be containers
+            for appenders and these are also searched for additional loggers.
+            </para>
+            <para>
+            The list returned is unordered but does not contain duplicates.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.
+            The appender may also be a container.
+            </summary>
+            <param name="appenderList"></param>
+            <param name="appender"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container
+            </summary>
+            <param name="appenderList"></param>
+            <param name="container"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the log4net system using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">
+            <summary>
+            Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="level">The level to check against.</param>
+            <returns>
+            <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.
+            </returns>
+            <remarks>
+            <para>
+            If this hierarchy has not been configured then this method will
+            always return <c>true</c>.
+            </para>
+            <para>
+            This method will return <c>true</c> if this repository is
+            disabled for <c>level</c> object passed as parameter and
+            <c>false</c> otherwise.
+            </para>
+            <para>
+            See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
+            <summary>
+            Clear all logger definitions from the internal hashtable
+            </summary>
+            <remarks>
+            <para>
+            This call will clear all logger definitions from the internal
+            hashtable. Invoking this method will irrevocably mess up the
+            logger hierarchy.
+            </para>
+            <para>
+            You should <b>really</b> know what you are doing before
+            invoking this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            <paramref name="factory"/>.
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <param name="factory">The factory that will make the new logger instance</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated by the
+            <paramref name="factory"/> parameter and linked with its existing
+            ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Sends a logger creation event to all registered listeners
+            </summary>
+            <param name="logger">The newly created logger</param>
+            <remarks>
+            Raises the logger creation event.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Updates all the parents of the specified logger
+            </summary>
+            <param name="log">The logger to update the parents for</param>
+            <remarks>
+            <para>
+            This method loops through all the <i>potential</i> parents of
+            <paramref name="log"/>. There 3 possible cases:
+            </para>
+            <list type="number">
+            	<item>
+            		<term>No entry for the potential parent of <paramref name="log"/> exists</term>
+            		<description>
+            		We create a ProvisionNode for this potential 
+            		parent and insert <paramref name="log"/> in that provision node.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type Logger for the potential parent.</term>
+            		<description>
+            		The entry is <paramref name="log"/>'s nearest existing parent. We 
+            		update <paramref name="log"/>'s parent field with this entry. We also break from 
+            		he loop because updating our parent's parent is our parent's 
+            		responsibility.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type ProvisionNode for this potential parent.</term>
+            		<description>
+            		We add <paramref name="log"/> to the list of children for this 
+            		potential parent.
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
+            </summary>
+            <param name="pn"></param>
+            <param name="log"></param>
+            <remarks>
+            <para>
+            We update the links for all the children that placed themselves
+            in the provision node 'pn'. The second argument 'log' is a
+            reference for the newly created Logger, parent of all the
+            children in 'pn'.
+            </para>
+            <para>
+            We loop on all the children 'c' in 'pn'.
+            </para>
+            <para>
+            If the child 'c' has been already linked to a child of
+            'log' then there is no need to update 'c'.
+            </para>
+            <para>
+            Otherwise, we set log's parent field to c's parent and set
+            c's parent field to log.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">
+            <summary>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="levelEntry">the level values</param>
+            <remarks>
+            <para>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </para>
+            <para>
+            Supports setting levels via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="propertyEntry">the property value</param>
+            <remarks>
+            <para>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.
+            </para>
+            <para>
+            Supports setting property values via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Hierarchy.declaringType">
+            <summary>
+            The fully qualified type of the Hierarchy class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">
+            <summary>
+            Event used to notify that a logger has been created.
+            </summary>
+            <remarks>
+            <para>
+            Event raised when a logger is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
+            <summary>
+            Has no appender warning been emitted
+            </summary>
+            <remarks>
+            <para>
+            Flag to indicate if we have already issued a warning
+            about not having an appender warning.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
+            <summary>
+            Get the root of this hierarchy
+            </summary>
+            <remarks>
+            <para>
+            Get the root of this hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
+            <summary>
+            Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.
+            </summary>
+            <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>
+            <remarks>
+            <para>
+            The logger factory is used to create logger instances.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">
+            <summary>
+            A class to hold the value, name and display name for a level
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the value, name and display name for a level
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">
+            <summary>
+            Value of the level
+            </summary>
+            <remarks>
+            <para>
+            If the value is not set (defaults to -1) the value will be looked
+            up for the current level with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">
+            <summary>
+            Name of the level
+            </summary>
+            <value>
+            The name of the level
+            </value>
+            <remarks>
+            <para>
+            The name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">
+            <summary>
+            Display name for the level
+            </summary>
+            <value>
+            The display name of the level
+            </value>
+            <remarks>
+            <para>
+            The display name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerKey">
+            <summary>
+            Used internally to accelerate hash table searches.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to improve performance of 
+            string keyed hashtables.
+            </para>
+            <para>
+            The hashcode of the string is cached for reuse.
+            The string is stored as an interned value.
+            When comparing two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> objects for equality 
+            the reference equality of the interned strings is compared.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.#ctor(System.String)">
+            <summary>
+            Construct key with string name
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> class 
+            with the specified name.
+            </para>
+            <para>
+            Stores the hashcode of the string and interns
+            the string key to optimize comparisons.
+            </para>
+            <note>
+            The Compact Framework 1.0 the <see cref="M:System.String.Intern(System.String)"/>
+            method does not work. On the Compact Framework
+            the string keys are not interned nor are they
+            compared by reference.
+            </note>
+            </remarks>
+            <param name="name">The name of the logger.</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.GetHashCode">
+            <summary>
+            Returns a hash code for the current instance.
+            </summary>
+            <returns>A hash code for the current instance.</returns>
+            <remarks>
+            <para>
+            Returns the cached hashcode.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.Equals(System.Object)">
+            <summary>
+            Determines whether two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> instances 
+            are equal.
+            </summary>
+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>.</param>
+            <returns>
+            <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>.
+            </returns>
+            <remarks>
+            <para>
+            Compares the references of the interned strings.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">
+            <summary>
+            Provision nodes are used where no logger instance has been specified
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> instances are used in the 
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> when there is no specified 
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> for that node.
+            </para>
+            <para>
+            A provision node holds a list of child loggers on behalf of
+            a logger that does not exist.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Create a new provision node with child node
+            </summary>
+            <param name="log">A child logger to add to this node.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> class 
+            with the specified child logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.RootLogger">
+            <summary>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> sits at the root of the logger hierarchy tree. 
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> is a regular <see cref="T:log4net.Repository.Hierarchy.Logger"/> except 
+            that it provides several guarantees.
+            </para>
+            <para>
+            First, it cannot be assigned a <c>null</c>
+            level. Second, since the root logger cannot have a parent, the
+            <see cref="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel"/> property always returns the value of the
+            level field without walking the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.Core.Level)">
+            <summary>
+            Construct a <see cref="T:log4net.Repository.Hierarchy.RootLogger"/>
+            </summary>
+            <param name="level">The level to assign to the root logger.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> class with
+            the specified logging level.
+            </para>
+            <para>
+            The root logger names itself as "root". However, the root
+            logger cannot be retrieved by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.RootLogger.declaringType">
+            <summary>
+            The fully qualified type of the RootLogger class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel">
+            <summary>
+            Gets the assigned level value without walking the logger hierarchy.
+            </summary>
+            <value>The assigned level value without walking the logger hierarchy.</value>
+            <remarks>
+            <para>
+            Because the root logger cannot have a parent and its level
+            must not be <c>null</c> this property just returns the
+            value of <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> for the root logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> of the root logger.
+            </value>
+            <remarks>
+            <para>
+            Setting the level of the root logger to a <c>null</c> reference
+            may have catastrophic results. We prevent this here.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator">
+            <summary>
+            Initializes the log4net environment using an XML DOM.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.#ctor(log4net.Repository.Hierarchy.Hierarchy)">
+            <summary>
+            Construct the configurator for a hierarchy
+            </summary>
+            <param name="hierarchy">The hierarchy to build.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator"/> class
+            with the specified <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </summary>
+            <param name="element">The root element to parse.</param>
+            <remarks>
+            <para>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">
+            <summary>
+            Parse appenders by IDREF.
+            </summary>
+            <param name="appenderRef">The appender ref element.</param>
+            <returns>The instance of the appender that the ref refers to.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return 
+            the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">
+            <summary>
+            Parses an appender element.
+            </summary>
+            <param name="appenderElement">The appender element.</param>
+            <returns>The appender instance or <c>null</c> when parsing failed.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return
+            the appender instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLogger(System.Xml.XmlElement)">
+            <summary>
+            Parses a logger element.
+            </summary>
+            <param name="loggerElement">The logger element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRoot(System.Xml.XmlElement)">
+            <summary>
+            Parses the root logger element.
+            </summary>
+            <param name="rootElement">The root element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses the children of a logger element.
+            </summary>
+            <param name="catElement">The category element.</param>
+            <param name="log">The logger instance.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse the child elements of a &lt;logger&gt; element.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement)">
+            <summary>
+            Parses an object renderer.
+            </summary>
+            <param name="element">The renderer element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a renderer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses a level element.
+            </summary>
+            <param name="element">The level element.</param>
+            <param name="log">The logger object to set the level on.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">
+            <summary>
+            Sets a parameter on an object.
+            </summary>
+            <param name="element">The parameter element.</param>
+            <param name="target">The object to set the parameter on.</param>
+            <remarks>
+            The parameter name must correspond to a writable property
+            on the object. The value of the parameter is a string,
+            therefore this function will attempt to set a string
+            property first. If unable to set a string property it
+            will inspect the property and its argument type. It will
+            attempt to call a static method called <c>Parse</c> on the
+            type of the property. This method will take a single
+            string argument and return a value that can be used to
+            set the property.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.HasAttributesOrElements(System.Xml.XmlElement)">
+            <summary>
+            Test if an element has no attributes or child elements
+            </summary>
+            <param name="element">the element to inspect</param>
+            <returns><c>true</c> if the element has any attributes or child elements, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.IsTypeConstructible(System.Type)">
+            <summary>
+            Test if a <see cref="T:System.Type"/> is constructible with <c>Activator.CreateInstance</c>.
+            </summary>
+            <param name="type">the type to inspect</param>
+            <returns><c>true</c> if the type is creatable using a default constructor, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindMethodInfo(System.Type,System.String)">
+            <summary>
+            Look for a method on the <paramref name="targetType"/> that matches the <paramref name="name"/> supplied
+            </summary>
+            <param name="targetType">the type that has the method</param>
+            <param name="name">the name of the method</param>
+            <returns>the method info found</returns>
+            <remarks>
+            <para>
+            The method must be a public instance method on the <paramref name="targetType"/>.
+            The method must be named <paramref name="name"/> or "Add" followed by <paramref name="name"/>.
+            The method must take a single parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string value to a target type.
+            </summary>
+            <param name="type">The type of object to convert the string to.</param>
+            <param name="value">The string value to use as the value of the object.</param>
+            <returns>
+            <para>
+            An object of type <paramref name="type"/> with value <paramref name="value"/> or 
+            <c>null</c> when the conversion could not be performed.
+            </para>
+            </returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement,System.Type,System.Type)">
+            <summary>
+            Creates an object as specified in XML.
+            </summary>
+            <param name="element">The XML element that contains the definition of the object.</param>
+            <param name="defaultTargetType">The object type to use if not explicitly specified.</param>
+            <param name="typeConstraint">The type that the returned object must be or must inherit from.</param>
+            <returns>The object or <c>null</c></returns>
+            <remarks>
+            <para>
+            Parse an XML element and create an object instance based on the configuration
+            data.
+            </para>
+            <para>
+            The type of the instance may be specified in the XML. If not
+            specified then the <paramref name="defaultTargetType"/> is used
+            as the type. However the type is specified it must support the
+            <paramref name="typeConstraint"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_appenderBag">
+            <summary>
+            key: appenderName, value: appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_hierarchy">
+            <summary>
+            The Hierarchy being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlHierarchyConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.ConfigurationChangedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.ConfigurationChangedEventArgs.#ctor(System.Collections.ICollection)">
+            <summary>
+            
+            </summary>
+            <param name="configurationMessages"></param>
+        </member>
+        <member name="P:log4net.Repository.ConfigurationChangedEventArgs.ConfigurationMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryShutdownEventHandler">
+            <summary>
+            Delegate used to handle logger repository shutdown event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository shutdown event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationResetEventHandler">
+            <summary>
+            Delegate used to handle logger repository configuration reset event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration reset.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository configuration reset event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationChangedEventHandler">
+            <summary>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration changed.</param>
+            <param name="e">Empty event arguments.</param>
+            <remarks>
+            <para>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppDomainPatternConverter">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the name of the current AppDomain to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppDomainPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes name of the current AppDomain to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppSettingPatternConverter">
+            <summary>
+            AppSetting pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads appSettings from the application configuration file.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single appSettings value. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all appSettings will be dumped as a list of key value pairs.
+            </para>
+            <para>
+            A typical use is to specify a base directory for log files, e.g.
+            <example>
+            <![CDATA[
+            <log4net>
+               <appender name="MyAppender" type="log4net.Appender.RollingFileAppender">
+                 <file type="log4net.Util.PatternString" value="appsetting{LogDirectory}MyApp.log"/>
+                  ...
+              </appender>
+            </log4net>
+            ]]>
+            </example>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppSettingPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.DatePatternConverter">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The date and time is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date and time passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter">
+            <summary>
+            Write an <see cref="T:System.Environment.SpecialFolder"/> folder path to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an special path environment folder path to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output. <see cref="P:log4net.Util.PatternConverter.Option"/>
+            should be a value in the <see cref="T:System.Environment.SpecialFolder"/> enumeration.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an special path environment folder path to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the special path environment folder path to the output <paramref name="writer"/>.
+            The name of the special path environment folder path to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentFolderPathPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentPatternConverter">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an environment variable to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the environment variable to the output <paramref name="writer"/>.
+            The name of the environment variable to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.IdentityPatternConverter">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current thread identity to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.IdentityPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the current thread identity to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.IdentityPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the IdentityPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">
+            <summary>
+            Pattern converter for literal string instances in the pattern
+            </summary>
+            <remarks>
+            <para>
+            Writes the literal string value specified in the 
+            <see cref="P:log4net.Util.PatternConverter.Option"/> property to 
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next converter in the chain
+            </summary>
+            <param name="pc">The next pattern converter in the chain</param>
+            <returns>The next pattern converter</returns>
+            <remarks>
+            <para>
+            Special case the building of the pattern converter chain
+            for <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> instances. Two adjacent
+            literals in the pattern can be represented by a single combined
+            pattern converter. This implementation detects when a 
+            <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> is added to the chain
+            after this converter and combines its value with this converter's
+            literal value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the literal to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            Override the formatting behavior to ignore the FormattingInfo
+            because we have a literal instead.
+            </para>
+            <para>
+            Writes the value of <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Convert this pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            This method is not used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.NewLinePatternConverter">
+            <summary>
+            Writes a newline to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the system dependent line terminator to the output.
+            This behavior can be overridden by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>:
+            </para>
+            <list type="definition">
+              <listheader>
+                <term>Option Value</term>
+                <description>Output</description>
+              </listheader>
+              <item>
+                <term>DOS</term>
+                <description>DOS or Windows line terminator <c>"\r\n"</c></description>
+              </item>
+              <item>
+                <term>UNIX</term>
+                <description>UNIX line terminator <c>"\n"</c></description>
+              </item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.ProcessIdPatternConverter">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current process ID to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current process ID to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the ProcessIdPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads the thread and global properties.
+            The thread properties take priority over global properties.
+            See <see cref="P:log4net.ThreadContext.Properties"/> for details of the 
+            thread properties. See <see cref="P:log4net.GlobalContext.Properties"/> for
+            details of the global properties.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single property. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all properties will be dumped as a list of key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.PropertyPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.RandomStringPatternConverter">
+            <summary>
+            A Pattern converter that generates a string of random characters
+            </summary>
+            <remarks>
+            <para>
+            The converter generates a string of random characters. By default
+            the string is length 4. This can be changed by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the string value of the length required.
+            </para>
+            <para>
+            The random characters in the string are limited to uppercase letters
+            and numbers only.
+            </para>
+            <para>
+            The random number generator used by this class is not cryptographically secure.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.s_random">
+            <summary>
+            Shared random number generator
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.m_length">
+            <summary>
+            Length of random string to generate. Default length 4.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write a randoim string to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write a randoim string to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the RandomStringPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UserNamePatternConverter">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current threads username to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UserNamePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current threads username to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UserNamePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UserNamePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter">
+            <summary>
+            Write the UTC date time to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UtcDatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date and time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date is in Universal time when it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.BooleanConverter">
+            <summary>
+            Type converter for Boolean.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <c>bool</c> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            <summary>
+            Exception base type for conversion errors.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConverterRegistry">
+            <summary>
+            Register of type converters for specific types.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a registry of type converters used to convert between
+            types.
+            </para>
+            <para>
+            Use the <see cref="M:AddConverter(Type, object)"/> and 
+            <see cref="M:AddConverter(Type, Type)"/> methods to register new converters.
+            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
+            lookup appropriate converters to use.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConverterRegistry"/> class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#cctor">
+            <summary>
+            Static constructor.
+            </summary>
+            <remarks>
+            <para>
+            This constructor defines the intrinsic type converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Object)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converter">The type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter instance for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Type)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converterType">The type of the type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter <see cref="T:System.Type"/> for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="sourceType">The type being converted from.</param>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConverterFromAttribute(System.Type)">
+            <summary>
+            Lookups the type converter to use as specified by the attributes on the 
+            destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.CreateConverterInstance(System.Type)">
+            <summary>
+            Creates the instance of the type converter.
+            </summary>
+            <param name="converterType">The type of the type converter.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            The type specified for the type converter must implement 
+            the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> or <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces 
+            and must have a public default (no argument) constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.declaringType">
+            <summary>
+            The fully qualified type of the ConverterRegistry class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.s_type2converter">
+            <summary>
+            Mapping from <see cref="T:System.Type"/> to type converter.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.EncodingConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an encoding</param>
+            <returns>the encoding</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to 
+            convert the <see cref="T:System.String"/> argument to an <see cref="T:System.Text.Encoding"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertTo">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from a single type to arbitrary types.
+            See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.CanConvertTo(System.Type)">
+            <summary>
+            Returns whether this converter can convert the object to the specified type
+            </summary>
+            <param name="targetType">A Type that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the type supported by this converter can be converted to the
+            <paramref name="targetType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> (which must be of the type supported
+            by this converter) to the <paramref name="targetType"/> specified..
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IPAddressConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an IPAddress</param>
+            <returns>the IPAddress</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Net.IPAddress.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to an <see cref="T:System.Net.IPAddress"/>.
+            If that fails then the string is resolved as a DNS hostname.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.IPAddressConverter.validIpAddressChars">
+            <summary>
+            Valid characters in an IPv4 or IPv6 address string. (Does not support subnets)
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternLayoutConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> 
+            of the <see cref="T:log4net.Layout.PatternLayout"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternLayout</param>
+            <returns>the PatternLayout</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Layout.PatternLayout"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternStringConverter">
+            <summary>
+            Convert between string and <see cref="T:log4net.Util.PatternString"/>
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Util.PatternString"/> type, 
+            and from a <see cref="T:log4net.Util.PatternString"/> type to a string.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Util.PatternString.ConversionPattern"/> 
+            of the <see cref="T:log4net.Util.PatternString"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)">
+            <summary>
+            Can the target type be converted to the type supported by this object
+            </summary>
+            <param name="targetType">A <see cref="T:System.Type"/> that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="targetType"/> is
+            assignable from a <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:PatternString.Format()"/> method to convert the
+            <see cref="T:log4net.Util.PatternString"/> argument to a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            <paramref name="targetType"/>. To check for this condition use the 
+            <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)"/> method.
+            </exception>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternString</param>
+            <returns>the PatternString</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Util.PatternString"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Util.PatternString.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a Type</param>
+            <returns>the Type</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Type"/>.
+            Additional effort is made to locate partially specified types
+            by searching the loaded assemblies.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">
+            <summary>
+            Attribute used to associate a type converter
+            </summary>
+            <remarks>
+            <para>
+            Class and Interface level attribute that specifies a type converter
+            to use with the associated type.
+            </para>
+            <para>
+            To associate a type converter with a target type apply a
+            <c>TypeConverterAttribute</c> to the target type. Specify the
+            type of the type converter on the attribute.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">
+            <summary>
+            The string type name of the type converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">
+            <summary>
+            Create a new type converter attribute for the specified type name
+            </summary>
+            <param name="typeName">The string type name of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">
+            <summary>
+            Create a new type converter attribute for the specified type
+            </summary>
+            <param name="converterType">The type of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">
+            <summary>
+            The string type name of the type converter 
+            </summary>
+            <value>
+            The string type name of the type converter 
+            </value>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.AppenderAttachedImpl">
+            <summary>
+            A straightforward implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This is the default implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/>
+            interface. Implementors of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            should aggregate an instance of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.AppenderAttachedImpl"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvents">The array of events being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.CallAppend(log4net.Appender.IAppender,log4net.Core.LoggingEvent[])">
+            <summary>
+            Calls the DoAppende method on the <see cref="T:log4net.Appender.IAppender"/> with 
+            the <see cref="T:log4net.Core.LoggingEvent"/> objects supplied.
+            </summary>
+            <param name="appender">The appender</param>
+            <param name="loggingEvents">The events</param>
+            <remarks>
+            <para>
+            If the <paramref name="appender"/> supports the <see cref="T:log4net.Appender.IBulkAppender"/>
+            interface then the <paramref name="loggingEvents"/> will be passed 
+            through using that interface. Otherwise the <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the array will be passed one at a time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="newAppender">The appender to add.</param>
+            <remarks>
+            <para>
+            If the appender is already in the list it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup an attached appender by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderList">
+            <summary>
+            List of appenders
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderArray">
+            <summary>
+            Array of appenders, used to cache the m_appenderList
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.declaringType">
+            <summary>
+            The fully qualified type of the AppenderAttachedImpl class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.AppenderAttachedImpl.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <returns>
+            A collection of attached appenders, or <c>null</c> if there
+            are no attached appenders.
+            </returns>
+            <remarks>
+            <para>
+            The read only collection of all currently attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CompositeProperties">
+            <summary>
+            This class aggregates several PropertiesDictionary collections together.
+            </summary>
+            <remarks>
+            <para>
+            Provides a dictionary style lookup over an ordered list of
+            <see cref="T:log4net.Util.PropertiesDictionary"/> collections.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CompositeProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Add(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Add a Properties Dictionary to this composite collection
+            </summary>
+            <param name="properties">the properties to add</param>
+            <remarks>
+            <para>
+            Properties dictionaries added first take precedence over dictionaries added
+            later.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Flatten">
+            <summary>
+            Flatten this composite collection into a single properties dictionary
+            </summary>
+            <returns>the flattened dictionary</returns>
+            <remarks>
+            <para>
+            Reduces the collection of ordered dictionaries to a single dictionary
+            containing the resultant values for the keys.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CompositeProperties.Item(System.String)">
+            <summary>
+            Gets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Looks up the value for the <paramref name="key"/> specified.
+            The <see cref="T:log4net.Util.PropertiesDictionary"/> collections are searched
+            in the order in which they were added to this collection. The value
+            returned is the value held by the first collection that contains
+            the specified key.
+            </para>
+            <para>
+            If none of the collections contain the specified key then
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ContextPropertiesBase">
+            <summary>
+            Base class for Context Properties implementations
+            </summary>
+            <remarks>
+            <para>
+            This class defines a basic property get set accessor
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ConverterInfo">
+            <summary>
+            Wrapper class used to map converter names to converter types
+            </summary>
+            <remarks>
+            <para>
+            Pattern converter info class used during configuration by custom
+            PatternString and PatternLayer converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.#ctor">
+            <summary>
+            default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            
+            </summary>
+            <param name="entry"></param>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Name">
+            <summary>
+            Gets or sets the name of the conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            The name of the pattern in the format string
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Type">
+            <summary>
+            Gets or sets the type of the converter
+            </summary>
+            <remarks>
+            <para>
+            The value specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.CountingQuietTextWriter">
+            <summary>
+            Subclass of <see cref="T:log4net.Util.QuietTextWriter"/> that maintains a count of 
+            the number of bytes written.
+            </summary>
+            <remarks>
+            <para>
+            This writer counts the number of bytes written.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.QuietTextWriter">
+            <summary>
+            <see cref="T:System.IO.TextWriter"/> that does not leak exceptions
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Util.QuietTextWriter"/> does not throw exceptions when things go wrong. 
+            Instead, it delegates error handling to its <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TextWriterAdapter">
+            <summary>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.TextWriterAdapter.m_writer">
+            <summary>
+            The writer to forward messages to
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Close">
+            <summary>
+            Closes the writer and releases any system resources associated with the writer
+            </summary>
+            <remarks>
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">
+            <summary>
+            Dispose this writer
+            </summary>
+            <param name="disposing">flag indicating if we are being disposed</param>
+            <remarks>
+            <para>
+            Dispose this writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Flush">
+            <summary>
+            Flushes any buffered output
+            </summary>
+            <remarks>
+            <para>
+            Clears all buffers for the writer and causes any buffered data to be written 
+            to the underlying device
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">
+            <summary>
+            Writes a character to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a character to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a character buffer to the wrapped TextWriter
+            </summary>
+            <param name="buffer">the data buffer</param>
+            <param name="index">the start index</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a character buffer to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">
+            <summary>
+            Writes a string to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a string to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Writer">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.IO.TextWriter"/>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Encoding">
+            <summary>
+            The Encoding in which the output is written
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>
+            </value>
+            <remarks>
+            <para>
+            The Encoding in which the output is written
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">
+            <summary>
+            Gets an object that controls formatting
+            </summary>
+            <value>
+            The format provider
+            </value>
+            <remarks>
+            <para>
+            Gets an object that controls formatting
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.NewLine">
+            <summary>
+            Gets or sets the line terminator string used by the TextWriter
+            </summary>
+            <value>
+            The line terminator to use
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the line terminator string used by the TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <param name="errorHandler">the error handler to report error to</param>
+            <remarks>
+            <para>
+            Create a new QuietTextWriter using a writer and error handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Writes a character to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a buffer to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output.
+            </summary>
+            <param name="value">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Writes a string to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Close">
+            <summary>
+            Closes the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_errorHandler">
+            <summary>
+            The error handler instance to pass all errors to
+            </summary>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_closed">
+            <summary>
+            Flag to indicate if this writer is closed
+            </summary>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.ErrorHandler">
+            <summary>
+            Gets or sets the error handler that all errors are passed to.
+            </summary>
+            <value>
+            The error handler that all errors are passed to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the error handler that all errors are passed to.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.Closed">
+            <summary>
+            Gets a value indicating whether this writer is closed.
+            </summary>
+            <value>
+            <c>true</c> if this writer is closed, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets a value indicating whether this writer is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to actually write to.</param>
+            <param name="errorHandler">The <see cref="T:log4net.Core.IErrorHandler"/> to report errors to.</param>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.CountingQuietTextWriter"/> class 
+            with the specified <see cref="T:System.IO.TextWriter"/> and <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output and counts the number of bytes written.
+            </summary>
+            <param name="str">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.CountingQuietTextWriter.m_countBytes">
+            <summary>
+            Total number of bytes written.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.CountingQuietTextWriter.Count">
+            <summary>
+            Gets or sets the total number of bytes written.
+            </summary>
+            <value>
+            The total number of bytes written.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the total number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CyclicBuffer">
+            <summary>
+            A fixed size rolling buffer of logging events.
+            </summary>
+            <remarks>
+            <para>
+            An array backed fixed size leaky bucket.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="maxSize">The maximum number of logging events in the buffer.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with 
+            the specified maximum number of buffered logging events.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Appends a <paramref name="loggingEvent"/> to the buffer.
+            </summary>
+            <param name="loggingEvent">The event to append to the buffer.</param>
+            <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Append an event to the buffer. If the buffer still contains free space then
+            <c>null</c> is returned. If the buffer is full then an event will be dropped
+            to make space for the new event, the event dropped is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopOldest">
+            <summary>
+            Get and remove the oldest event in the buffer.
+            </summary>
+            <returns>The oldest logging event in the buffer</returns>
+            <remarks>
+            <para>
+            Gets the oldest (first) logging event in the buffer and removes it 
+            from the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopAll">
+            <summary>
+            Pops all the logging events from the buffer into an array.
+            </summary>
+            <returns>An array of all the logging events in the buffer.</returns>
+            <remarks>
+            <para>
+            Get all the events in the buffer and clear the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Clear">
+            <summary>
+            Clear the buffer
+            </summary>
+            <remarks>
+            <para>
+            Clear the buffer of all events. The events in the buffer are lost.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">
+            <summary>
+            Gets the <paramref name="i"/>th oldest event currently in the buffer.
+            </summary>
+            <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>
+            <remarks>
+            <para>
+            If <paramref name="i"/> is outside the range 0 to the number of events
+            currently in the buffer, then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.MaxSize">
+            <summary>
+            Gets the maximum size of the buffer.
+            </summary>
+            <value>The maximum size of the buffer.</value>
+            <remarks>
+            <para>
+            Gets the maximum size of the buffer
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Length">
+            <summary>
+            Gets the number of logging events in the buffer.
+            </summary>
+            <value>The number of logging events in the buffer.</value>
+            <remarks>
+            <para>
+            This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>
+            (inclusive).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyCollection">
+            <summary>
+            An always empty <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.ICollection"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyCollection"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.EmptyCollection.s_instance">
+            <summary>
+            The singleton instance of the empty collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Instance">
+            <summary>
+            Gets the singleton instance of the empty collection.
+            </summary>
+            <returns>The singleton instance of the empty collection.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the empty collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyCollection.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyCollection.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyDictionary">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionary"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyDictionary"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Add(System.Object,System.Object)">
+            <summary>
+            Adds an element with the provided key and value to the 
+            <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>
+            <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>
+            <remarks>
+            <para>
+            As the collection is empty no new values can be added. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Clear">
+            <summary>
+            Removes all elements from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Contains(System.Object)">
+            <summary>
+            Determines whether the <see cref="T:log4net.Util.EmptyDictionary"/> contains an element 
+            with the specified key.
+            </summary>
+            <param name="key">The key to locate in the <see cref="T:log4net.Util.EmptyDictionary"/>.</param>
+            <returns><c>false</c></returns>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="M:log4net.Util.EmptyDictionary.Contains(System.Object)"/> method always returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Remove(System.Object)">
+            <summary>
+            Removes the element with the specified key from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The key of the element to remove.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="F:log4net.Util.EmptyDictionary.s_instance">
+            <summary>
+            The singleton instance of the empty dictionary.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <b>true</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyDictionary.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyDictionary.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> has a fixed size.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsFixedSize"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> is read-only.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsReadOnly"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Keys">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Values">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Item(System.Object)">
+            <summary>
+            Gets or sets the element with the specified key.
+            </summary>
+            <param name="key">The key of the element to get or set.</param>
+            <value><c>null</c></value>
+            <remarks>
+            <para>
+            As the collection is empty no values can be looked up or stored. 
+            If the index getter is called then <c>null</c> is returned.
+            A <see cref="T:System.InvalidOperationException"/> is thrown if the setter is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="T:log4net.Util.FormattingInfo">
+            <summary>
+            Contain the information obtained when parsing formatting modifiers 
+            in conversion modifiers.
+            </summary>
+            <remarks>
+            <para>
+            Holds the formatting information extracted from the format string by
+            the <see cref="T:log4net.Util.PatternParser"/>. This is used by the <see cref="T:log4net.Util.PatternConverter"/>
+            objects when rendering the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor">
+            <summary>
+            Defaut Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor(System.Int32,System.Int32,System.Boolean)">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class
+            with the specified parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Min">
+            <summary>
+            Gets or sets the minimum value.
+            </summary>
+            <value>
+            The minimum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the minimum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Max">
+            <summary>
+            Gets or sets the maximum value.
+            </summary>
+            <value>
+            The maximum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the maximum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.LeftAlign">
+            <summary>
+            Gets or sets a flag indicating whether left align is enabled
+            or not.
+            </summary>
+            <value>
+            A flag indicating whether left align is enabled or not.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a flag indicating whether left align is enabled or not.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.GlobalContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.GlobalContext"/>
+            </summary>
+            <remarks>
+            <para>
+            This class implements a properties collection that is thread safe and supports both
+            storing properties and capturing a read only copy of the current propertied.
+            </para>
+            <para>
+            This class is optimized to the scenario where the properties are read frequently
+            and are modified infrequently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_readOnlyProperties">
+            <summary>
+            The read only copy of the properties.
+            </summary>
+            <remarks>
+            <para>
+            This variable is declared <c>volatile</c> to prevent the compiler and JIT from
+            reordering reads and writes of this thread performed on different threads.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_syncRoot">
+            <summary>
+            Lock object used to synchronize updates within this instance
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.GlobalContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property from the global context
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Removing an entry from the global context properties is relatively expensive compared
+            with reading a value. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Clear">
+            <summary>
+            Clear the global context properties
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.GetReadOnlyProperties">
+            <summary>
+            Get a readonly immutable copy of the properties
+            </summary>
+            <returns>the current global context properties</returns>
+            <remarks>
+            <para>
+            This implementation is fast because the GlobalContextProperties class
+            stores a readonly copy of the properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.GlobalContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Reading the value for a key is faster than setting the value.
+            When the value is written a new read only copy of 
+            the properties is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ILogExtensions">
+            <summary>
+            The static class ILogExtensions contains a set of widely used
+            methods that ease the interaction with the ILog interface implementations.
+            </summary>
+            <remarks>
+            <para>
+            This class contains methods for logging at different levels and checks the
+            properties for determining if those logging levels are enabled in the current
+            configuration.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            using log4net.Util;
+            
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.InfoExt("Application Start");
+            log.DebugExt("This is a debug message");
+            </code>
+            </example>
+        </member>
+        <member name="F:log4net.Util.ILogExtensions.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="T:log4net.Util.LevelMapping">
+            <summary>
+            Manages a mapping from levels to <see cref="T:log4net.Util.LevelMappingEntry"/>
+            </summary>
+            <remarks>
+            <para>
+            Manages an ordered mapping from <see cref="T:log4net.Core.Level"/> instances 
+            to <see cref="T:log4net.Util.LevelMappingEntry"/> subclasses.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialise a new instance of <see cref="T:log4net.Util.LevelMapping"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Add(log4net.Util.LevelMappingEntry)">
+            <summary>
+            Add a <see cref="T:log4net.Util.LevelMappingEntry"/> to this mapping
+            </summary>
+            <param name="entry">the entry to add</param>
+            <remarks>
+            <para>
+            If a <see cref="T:log4net.Util.LevelMappingEntry"/> has previously been added
+            for the same <see cref="T:log4net.Core.Level"/> then that entry will be 
+            overwritten.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Lookup(log4net.Core.Level)">
+            <summary>
+            Lookup the mapping for the specified level
+            </summary>
+            <param name="level">the level to lookup</param>
+            <returns>the <see cref="T:log4net.Util.LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
+            <remarks>
+            <para>
+            Lookup the value for the specified level. Finds the nearest
+            mapping value for the level that is equal to or less than the
+            <paramref name="level"/> specified.
+            </para>
+            <para>
+            If no mapping could be found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.ActivateOptions">
+            <summary>
+            Initialize options
+            </summary>
+            <remarks>
+            <para>
+            Caches the sorted list of <see cref="T:log4net.Util.LevelMappingEntry"/> in an array
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            <para>
+            This class stores its properties in a slot on the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> named
+            <c>log4net.Util.LogicalThreadContextProperties</c>.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.m_disabled">
+            <summary>
+            Flag used to disable this context if we don't have permission to access the CallContext.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the value for the specified <paramref name="key"/> from the context.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Clear">
+            <summary>
+            Clear all the context properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all the context properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the PropertiesDictionary stored in the LocalDataStoreSlot for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doings so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetLogicalProperties">
+            <summary>
+            Gets the call context get data.
+            </summary>
+            <returns>The peroperties dictionary stored in the call context</returns>
+            <remarks>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.GetData(System.String)"/> has a
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.SetLogicalProperties(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Sets the call context data.
+            </summary>
+            <param name="properties">The properties.</param>
+            <remarks>
+            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
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.declaringType">
+            <summary>
+            The fully qualified type of the LogicalThreadContextProperties class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Get or set the property value for the <paramref name="key"/> specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TwoArgAction`2">
+            <summary>
+            Delegate type used for LogicalThreadContextStack's callbacks.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_propertyKey">
+            <summary>
+            The name of this <see cref="T:log4net.Util.LogicalThreadContextStack"/> within the
+            <see cref="T:log4net.Util.LogicalThreadContextProperties"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_registerNew">
+            <summary>
+            The callback used to let the <see cref="T:log4net.Util.LogicalThreadContextStacks"/> register a
+            new instance of a <see cref="T:log4net.Util.LogicalThreadContextStack"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.#ctor(System.String,log4net.Util.TwoArgAction{System.String,log4net.Util.LogicalThreadContextStack})">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this thread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.LogicalThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.LogicalThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_logicalThreadContextStack">
+            <summary>
+            The outer LogicalThreadContextStack.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.#ctor(log4net.Util.LogicalThreadContextStack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="logicalThreadContextStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStacks.#ctor(log4net.Util.LogicalThreadContextProperties)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventHandler">
+            <summary>
+            
+            </summary>
+            <param name="source"></param>
+            <param name="e"></param>
+        </member>
+        <member name="T:log4net.Util.LogLog">
+            <summary>
+            Outputs log statements from within the log4net assembly.
+            </summary>
+            <remarks>
+            <para>
+            Log4net components cannot make log4net logging calls. However, it is
+            sometimes useful for the user to learn about what log4net is
+            doing.
+            </para>
+            <para>
+            All log4net internal debug calls go to the standard output stream
+            whereas internal error messages are sent to the standard error output 
+            stream.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.LogLog.ToString">
+            <summary>
+            Formats Prefix, Source, and Message in the same format as the value
+            sent to Console.Out and Trace.Write.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.LogLog.#ctor(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogLog"/> class. 
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.#cctor">
+            <summary>
+            Static constructor that initializes logging by reading 
+            settings from the application configuration file.
+            </summary>
+            <remarks>
+            <para>
+            The <c>log4net.Internal.Debug</c> application setting
+            controls internal debugging. This setting should be set
+            to <c>true</c> to enable debugging.
+            </para>
+            <para>
+            The <c>log4net.Internal.Quiet</c> application setting
+            suppresses all internal logging including error messages. 
+            This setting should be set to <c>true</c> to enable message
+            suppression.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.OnLogReceived(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Raises the LogReceived event when an internal messages is received.
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source"></param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal error messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitOutLine(System.String)">
+            <summary>
+            Writes output to the standard output stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Out and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitErrorLine(System.String)">
+            <summary>
+            Writes output to the standard error stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Error and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_debugEnabled">
+            <summary>
+             Default debug level
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_quietMode">
+            <summary>
+            In quietMode not even errors generate any output.
+            </summary>
+        </member>
+        <member name="E:log4net.Util.LogLog.LogReceived">
+            <summary>
+            The event raised when an internal message has been received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Source">
+            <summary>
+            The Type that generated the internal message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStamp">
+            <summary>
+            The DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStampUtc">
+            <summary>
+            The UTC DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Prefix">
+            <summary>
+            A string indicating the severity of the internal message.
+            </summary>
+            <remarks>
+            "log4net: ", 
+            "log4net:ERROR ", 
+            "log4net:WARN "
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.Message">
+            <summary>
+            The internal log message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Exception">
+            <summary>
+            The Exception related to the message.
+            </summary>
+            <remarks>
+            Optional. Will be null if no Exception was passed.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.InternalDebugging">
+            <summary>
+            Gets or sets a value indicating whether log4net internal logging
+            is enabled or disabled.
+            </summary>
+            <value>
+            <c>true</c> if log4net internal logging is enabled, otherwise 
+            <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c>, internal debug level logging will be 
+            displayed.
+            </para>
+            <para>
+            This value can be set by setting the application setting 
+            <c>log4net.Internal.Debug</c> in the application configuration
+            file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. debugging is
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            The following example enables internal debugging using the 
+            application configuration file :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Debug" value="true" />
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.QuietMode">
+            <summary>
+            Gets or sets a value indicating whether log4net should generate no output
+            from internal logging, not even for errors. 
+            </summary>
+            <value>
+            <c>true</c> if log4net should generate no output at all from internal 
+            logging, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c> will cause internal logging at all levels to be 
+            suppressed. This means that no warning or error reports will be logged. 
+            This option overrides the <see cref="P:log4net.Util.LogLog.InternalDebugging"/> setting and 
+            disables all debug also.
+            </para>
+            <para>This value can be set by setting the application setting
+            <c>log4net.Internal.Quiet</c> in the application configuration file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. internal logging is not
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            The following example disables internal logging using the 
+            application configuration file :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Quiet" value="true"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.EmitInternalMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsDebugEnabled">
+            <summary>
+            Test if LogLog.Debug is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Debug is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Debug is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsWarnEnabled">
+            <summary>
+            Test if LogLog.Warn is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Warn is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Warn is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsErrorEnabled">
+            <summary>
+            Test if LogLog.Error is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Error is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Error is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogLog.LogReceivedAdapter">
+            <summary>
+            Subscribes to the LogLog.LogReceived event and stores messages
+            to the supplied IList instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.#ctor(System.Collections.IList)">
+            <summary>
+            
+            </summary>
+            <param name="items"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.Dispose">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.LogReceivedAdapter.Items">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogReceivedEventArgs.#ctor(log4net.Util.LogLog)">
+            <summary>
+            
+            </summary>
+            <param name="loglog"></param>
+        </member>
+        <member name="P:log4net.Util.LogReceivedEventArgs.LogLog">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.NativeError">
+            <summary>
+            Represents a native error code and message.
+            </summary>
+            <remarks>
+            <para>
+            Represents a Win32 platform native error.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NativeError.#ctor(System.Int32,System.String)">
+            <summary>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </summary>
+            <param name="number">The number of the native error.</param>
+            <param name="message">The message of the native error.</param>
+            <remarks>
+            <para>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetLastError">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class for the last Windows error.
+            </summary>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the last windows error.
+            </returns>
+            <remarks>
+            <para>
+            The message for the <see cref="M:System.Runtime.InteropServices.Marshal.GetLastWin32Error"/> error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetError(System.Int32)">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class.
+            </summary>
+            <param name="number">the error number for the native error</param>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the specified 
+            error number.
+            </returns>
+            <remarks>
+            <para>
+            The message for the specified error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetErrorMessage(System.Int32)">
+            <summary>
+            Retrieves the message corresponding with a Win32 message identifier.
+            </summary>
+            <param name="messageId">Message identifier for the requested message.</param>
+            <returns>
+            The message corresponding with the specified message identifier.
+            </returns>
+            <remarks>
+            <para>
+            The message will be searched for in system message-table resource(s)
+            using the native <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.ToString">
+            <summary>
+            Return error information string
+            </summary>
+            <returns>error information string</returns>
+            <remarks>
+            <para>
+            Return error information string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.FormatMessage(System.Int32,System.IntPtr@,System.Int32,System.Int32,System.String@,System.Int32,System.IntPtr)">
+            <summary>
+            Formats a message string.
+            </summary>
+            <param name="dwFlags">Formatting options, and how to interpret the <paramref name="lpSource" /> parameter.</param>
+            <param name="lpSource">Location of the message definition.</param>
+            <param name="dwMessageId">Message identifier for the requested message.</param>
+            <param name="dwLanguageId">Language identifier for the requested message.</param>
+            <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>
+            <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>
+            <param name="Arguments">Pointer to an array of values that are used as insert values in the formatted message.</param>
+            <remarks>
+            <para>
+            The function requires a message definition as input. The message definition can come from a 
+            buffer passed into the function. It can come from a message table resource in an 
+            already-loaded module. Or the caller can ask the function to search the system's message 
+            table resource(s) for the message definition. The function finds the message definition 
+            in a message table resource based on a message identifier and a language identifier. 
+            The function copies the formatted message text to an output buffer, processing any embedded 
+            insert sequences if requested.
+            </para>
+            <para>
+            To prevent the usage of unsafe code, this stub does not support inserting values in the formatted message.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is the number of TCHARs stored in the output 
+            buffer, excluding the terminating null character.
+            </para>
+            <para>
+            If the function fails, the return value is zero. To get extended error information, 
+            call <see cref="M:Marshal.GetLastWin32Error()" />.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Util.NativeError.Number">
+            <summary>
+            Gets the number of the native error.
+            </summary>
+            <value>
+            The number of the native error.
+            </value>
+            <remarks>
+            <para>
+            Gets the number of the native error.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NativeError.Message">
+            <summary>
+            Gets the message of the native error.
+            </summary>
+            <value>
+            The message of the native error.
+            </value>
+            <remarks>
+            <para>
+            </para>
+            Gets the message of the native error.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.NullDictionaryEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionaryEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionaryEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance.
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullDictionaryEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullDictionaryEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullDictionaryEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Key">
+            <summary>
+            Gets the current key from the enumerator.
+            </summary>
+            <remarks>
+            Throws an exception because the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>
+            never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Key"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Value">
+            <summary>
+            Gets the current value from the enumerator.
+            </summary>
+            <value>The current value from the enumerator.</value>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Value"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Entry">
+            <summary>
+            Gets the current entry from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current entry.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Entry"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Instance">
+            <summary>
+            Get the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullSecurityContext">
+            <summary>
+            A SecurityContext used when a SecurityContext is not required
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Util.NullSecurityContext"/> is a no-op implementation of the
+            <see cref="T:log4net.Core.SecurityContext"/> base class. It is used where a <see cref="T:log4net.Core.SecurityContext"/>
+            is required but one has not been provided.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.NullSecurityContext.Instance">
+            <summary>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            <para>
+            Private constructor for singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns><c>null</c></returns>
+            <remarks>
+            <para>
+            No impersonation is done and <c>null</c> is always returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OnlyOnceErrorHandler">
+            <summary>
+            Implements log4net's default error handling policy which consists 
+            of emitting a message for the first error in an appender and 
+            ignoring all subsequent errors.
+            </summary>
+            <remarks>
+            <para>
+            The error message is processed using the LogLog sub-system by default.
+            </para>
+            <para>
+            This policy aims at protecting an otherwise working application
+            from being flooded with error messages when logging fails.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="prefix">The prefix to use for each message.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class
+            with the specified prefix.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Reset">
+            <summary>
+            Reset the error handler back to its initial disabled state.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log the very first error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            Sends the error information to <see cref="T:log4net.Util.LogLog"/>'s Error method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">
+            <summary>
+            Log an error
+            </summary>
+            <param name="message">The error message.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_enabledDateUtc">
+            <summary>
+            The UTC date the error was recorded.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">
+            <summary>
+            Flag to indicate if it is the first error
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_message">
+            <summary>
+            The message recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_exception">
+            <summary>
+            The exception recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_errorCode">
+            <summary>
+            The error code recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">
+            <summary>
+            String to prefix each message with
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.declaringType">
+            <summary>
+            The fully qualified type of the OnlyOnceErrorHandler class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">
+            <summary>
+            Is error logging enabled
+            </summary>
+            <remarks>
+            <para>
+            Is error logging enabled. Logging is only enabled for the
+            first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDate">
+            <summary>
+            The date the first error that trigged this error handler occurred, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDateUtc">
+            <summary>
+            The UTC date the first error that trigged this error handler occured, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorMessage">
+            <summary>
+            The message from the first error that trigged this error handler.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.Exception">
+            <summary>
+            The exception from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            May be <see langword="null" />.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorCode">
+            <summary>
+            The error code from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            Defaults to <see cref="F:log4net.Core.ErrorCode.GenericFailure"/>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OptionConverter">
+            <summary>
+            A convenience class to convert property values to specific types.
+            </summary>
+            <remarks>
+            <para>
+            Utility functions for converting types and parsing values.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.OptionConverter"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToBoolean(System.String,System.Boolean)">
+            <summary>
+            Converts a string to a <see cref="T:System.Boolean"/> value.
+            </summary>
+            <param name="argValue">String to convert.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Boolean"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            If <paramref name="argValue"/> is "true", then <c>true</c> is returned. 
+            If <paramref name="argValue"/> is "false", then <c>false</c> is returned. 
+            Otherwise, <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToFileSize(System.String,System.Int64)">
+            <summary>
+            Parses a file size into a number.
+            </summary>
+            <param name="argValue">String to parse.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Int64"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            Parses a file size of the form: number[KB|MB|GB] into a
+            long value. It is scaled with the appropriate multiplier.
+            </para>
+            <para>
+            <paramref name="defaultValue"/> is returned when <paramref name="argValue"/>
+            cannot be converted to a <see cref="T:System.Int64"/> value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string to an object.
+            </summary>
+            <param name="target">The target type to convert to.</param>
+            <param name="txt">The string to convert to an object.</param>
+            <returns>
+            The object converted from a string or <c>null</c> when the 
+            conversion failed.
+            </returns>
+            <remarks>
+            <para>
+            Converts a string to an object. Uses the converter registry to try
+            to convert the string value into the specified target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.CanConvertTypeTo(System.Type,System.Type)">
+            <summary>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            </summary>
+            <param name="sourceType">The type to convert from.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns><c>true</c> if there is a conversion from the source type to the target type.</returns>
+            <remarks>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertTypeTo(System.Object,System.Type)">
+            <summary>
+            Converts an object to the target type.
+            </summary>
+            <param name="sourceInstance">The object to convert to the target type.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns>The converted object.</returns>
+            <remarks>
+            <para>
+            Converts an object to the target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">
+            <summary>
+            Instantiates an object given a class name.
+            </summary>
+            <param name="className">The fully qualified class name of the object to instantiate.</param>
+            <param name="superClass">The class to which the new object should belong.</param>
+            <param name="defaultValue">The object to return in case of non-fulfillment.</param>
+            <returns>
+            An instance of the <paramref name="className"/> or <paramref name="defaultValue"/>
+            if the object could not be instantiated.
+            </returns>
+            <remarks>
+            <para>
+            Checks that the <paramref name="className"/> is a subclass of
+            <paramref name="superClass"/>. If that test fails or the object could
+            not be instantiated, then <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.SubstituteVariables(System.String,System.Collections.IDictionary)">
+            <summary>
+            Performs variable substitution in string <paramref name="value"/> from the 
+            values of keys found in <paramref name="props"/>.
+            </summary>
+            <param name="value">The string on which variable substitution is performed.</param>
+            <param name="props">The dictionary to use to lookup variables.</param>
+            <returns>The result of the substitutions.</returns>
+            <remarks>
+            <para>
+            The variable substitution delimiters are <b>${</b> and <b>}</b>.
+            </para>
+            <para>
+            For example, if props contains <c>key=value</c>, then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of key is ${key}.");
+            </code>
+            </para>
+            <para>
+            will set the variable <c>s</c> to "Value of key is value.".
+            </para>
+            <para>
+            If no value could be found for the specified key, then substitution 
+            defaults to an empty string.
+            </para>
+            <para>
+            For example, if system properties contains no value for the key
+            "nonExistentKey", then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of nonExistentKey is [${nonExistentKey}]");
+            </code>
+            </para>
+            <para>
+            will set <s>s</s> to "Value of nonExistentKey is []".	 
+            </para>
+            <para>
+            An Exception is thrown if <paramref name="value"/> contains a start 
+            delimiter "${" which is not balanced by a stop delimiter "}". 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ParseEnum(System.Type,System.String,System.Boolean)">
+            <summary>
+            Converts the string representation of the name or numeric value of one or 
+            more enumerated constants to an equivalent enumerated object.
+            </summary>
+            <param name="enumType">The type to convert to.</param>
+            <param name="value">The enum string value.</param>
+            <param name="ignoreCase">If <c>true</c>, ignore case; otherwise, regard case.</param>
+            <returns>An object of type <paramref name="enumType" /> whose value is represented by <paramref name="value" />.</returns>
+        </member>
+        <member name="F:log4net.Util.OptionConverter.declaringType">
+            <summary>
+            The fully qualified type of the OptionConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser">
+            <summary>
+            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class
+            is delegated to the PatternParser class.
+            </summary>
+            <remarks>
+            <para>
+            The <c>PatternParser</c> processes a pattern string and
+            returns a chain of <see cref="T:log4net.Util.PatternConverter"/> objects.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.PatternParser.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="pattern">The pattern to parse.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternParser"/> class 
+            with the specified pattern string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.Parse">
+            <summary>
+            Parses the pattern into a chain of pattern converters.
+            </summary>
+            <returns>The head of a chain of pattern converters.</returns>
+            <remarks>
+            <para>
+            Parses the pattern into a chain of pattern converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.BuildCache">
+            <summary>
+            Build the unified cache of converters from the static and instance maps
+            </summary>
+            <returns>the list of all the converter names</returns>
+            <remarks>
+            <para>
+            Build the unified cache of converters from the static and instance maps
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ParseInternal(System.String,System.String[])">
+            <summary>
+            Internal method to parse the specified pattern to find specified matches
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <param name="matches">the converter names to match in the pattern</param>
+            <remarks>
+            <para>
+            The matches param must be sorted such that longer strings come before shorter ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessLiteral(System.String)">
+            <summary>
+            Process a parsed literal
+            </summary>
+            <param name="text">the literal text</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessConverter(System.String,System.String,log4net.Util.FormattingInfo)">
+            <summary>
+            Process a parsed converter pattern
+            </summary>
+            <param name="converterName">the name of the converter</param>
+            <param name="option">the optional option for the converter</param>
+            <param name="formattingInfo">the formatting info for the converter</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.AddConverter(log4net.Util.PatternConverter)">
+            <summary>
+            Resets the internal state of the parser and adds the specified pattern converter 
+            to the chain.
+            </summary>
+            <param name="pc">The pattern converter to add.</param>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_head">
+            <summary>
+            The first pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_tail">
+            <summary>
+             the last pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_pattern">
+            <summary>
+            The pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_patternConverters">
+            <summary>
+            Internal map of converter identifiers to converter types
+            </summary>
+            <remarks>
+            <para>
+            This map overrides the static s_globalRulesRegistry map.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternParser.declaringType">
+            <summary>
+            The fully qualified type of the PatternParser class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternParser.PatternConverters">
+            <summary>
+            Get the converter registry used by this parser
+            </summary>
+            <value>
+            The converter registry used by this parser
+            </value>
+            <remarks>
+            <para>
+            Get the converter registry used by this parser
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser.StringLengthComparer">
+            <summary>
+            Sort strings by length
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:System.Collections.IComparer"/> that orders strings by string length.
+            The longest strings are placed first
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternString">
+            <summary>
+            This class implements a patterned string.
+            </summary>
+            <remarks>
+            <para>
+            This string has embedded patterns that are resolved and expanded
+            when the string is formatted.
+            </para>
+            <para>
+            This class functions similarly to the <see cref="T:log4net.Layout.PatternLayout"/>
+            in that it accepts a pattern and renders it to a string. Unlike the 
+            <see cref="T:log4net.Layout.PatternLayout"/> however the <c>PatternString</c>
+            does not render the properties of a specific <see cref="T:log4net.Core.LoggingEvent"/> but
+            of the process in general.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+                        <para>
+                        Used to output the friendly name of the current AppDomain.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>appsetting</term>
+                    <description>
+                        <para>
+                        Used to output the value of a specific appSetting key in the application
+                        configuration file.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>date</term>
+                    <description>
+            			<para>
+            			Used to output the current date and time in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>env</term>
+                    <description>
+                        <para>
+            			Used to output the a specific environment variable. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%env{COMPUTERNAME}</b> would include the value
+            			of the <c>COMPUTERNAME</c> environment variable.
+                        </para>
+                        <para>
+                        The <c>env</c> pattern is not supported on the .NET Compact Framework.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>identity</term>
+                    <description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>newline</term>
+                    <description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern name offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+                    </description>
+                </item>
+                <item>
+                    <term>processid</term>
+                    <description>
+                        <para>
+            			Used to output the system process ID for the current process.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>property</term>
+                    <description>
+            			<para>
+            			Used to output a specific context property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are stored in logging contexts. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+                    </description>
+                </item>
+                <item>
+                    <term>random</term>
+                    <description>
+                        <para>
+                        Used to output a random string of characters. The string is made up of
+                        uppercase letters and numbers. By default the string is 4 characters long.
+                        The length of the string can be specified within braces directly following the
+            			pattern specifier, e.g. <b>%random{8}</b> would output an 8 character string.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>username</term>
+                    <description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>utcdate</term>
+                    <description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Util.PatternString"/>
+            instance using <see cref="M:AddConverter(ConverterInfo)"/> or
+            <see cref="M:AddConverter(string, Type)"/>.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.PatternLayout"/> for details on the 
+            <i>format modifiers</i> supported by the patterns.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternString.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternString only
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor(System.String)">
+            <summary>
+            Constructs a PatternString
+            </summary>
+            <param name="pattern">The pattern to use with this PatternString</param>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/> with the pattern specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.ActivateOptions">
+            <summary>
+            Initialize object options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternString.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternString.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternString.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.CreatePatternParser(System.String)">
+            <summary>
+            Create the <see cref="T:log4net.Util.PatternParser"/> used to parse the pattern
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/></returns>
+            <remarks>
+            <para>
+            Returns PatternParser used to parse the conversion string. Subclasses
+            may override this to return a subclass of PatternParser which recognize
+            custom conversion pattern name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format(System.IO.TextWriter)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the pattern to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format">
+            <summary>
+            Format the pattern as a string
+            </summary>
+            <returns>the pattern formatted as a string</returns>
+            <remarks>
+            <para>
+            Format the pattern to a string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a converter to this PatternString
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternString.ConversionPattern">
+            <summary>
+            Gets or sets the pattern formatting string
+            </summary>
+            <value>
+            The pattern formatting string
+            </value>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PropertiesDictionary">
+            <summary>
+            String keyed object map.
+            </summary>
+            <remarks>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.ReadOnlyPropertiesDictionary">
+            <summary>
+            String keyed object map that is read only.
+            </summary>
+            <remarks>
+            <para>
+            This collection is readonly and cannot be modified.
+            </para>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.ReadOnlyPropertiesDictionary.m_hashtable">
+            <summary>
+            The Hashtable used to store the properties data
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Copy Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Deserialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetKeys">
+            <summary>
+            Gets the key names.
+            </summary>
+            <returns>An array of all the keys.</returns>
+            <remarks>
+            <para>
+            Gets the key names.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Contains(System.String)">
+            <summary>
+            Test if the dictionary contains a specified key
+            </summary>
+            <param name="key">the key to look for</param>
+            <returns>true if the dictionary contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if the dictionary contains a specified key
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <param name="value"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.InnerHashtable">
+            <summary>
+            The hashtable used to store the properties
+            </summary>
+            <value>
+            The internal collection used to store the properties
+            </value>
+            <remarks>
+            <para>
+            The hashtable used to store the properties
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Count">
+            <summary>
+            The number of properties in this collection
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class 
+            with serialized data.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Because this class is sealed the serialization constructor is private.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Remove(System.String)">
+            <summary>
+            Remove the entry with the specified key from this dictionary
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+            <returns>an enumerator</returns>
+            <remarks>
+            <para>
+            Returns a <see cref="T:System.Collections.IDictionaryEnumerator"/> over the contest of this collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key">the key to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key">the key to lookup in the collection</param>
+            <returns><c>true</c> if the collection contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if this collection contains a specified key.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+            <remarks>
+            <para>
+            Remove all properties from the properties collection
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key">the key</param>
+            <param name="value">the value to store for the key</param>
+            <remarks>
+            <para>
+            Store a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+            <value>
+            <c>false</c>
+            </value>
+            <remarks>
+            <para>
+            This collection is modifiable. This property always
+            returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+            <value>
+            The value for the key specified.
+            </value>
+            <remarks>
+            <para>
+            Get or set a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="T:log4net.Util.PropertyEntry">
+            <summary>
+            A class to hold the key and data for a property set in the config file
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the key and data for a property set in the config file
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertyEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Key">
+            <summary>
+            Property Key
+            </summary>
+            <value>
+            Property Key
+            </value>
+            <remarks>
+            <para>
+            Property Key.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Value">
+            <summary>
+            Property Value
+            </summary>
+            <value>
+            Property Value
+            </value>
+            <remarks>
+            <para>
+            Property Value.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ProtectCloseTextWriter">
+            <summary>
+            A <see cref="T:System.IO.TextWriter"/> that ignores the <see cref="M:log4net.Util.ProtectCloseTextWriter.Close"/> message
+            </summary>
+            <remarks>
+            <para>
+            This writer is used in special cases where it is necessary 
+            to protect a writer from being closed by a client.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <remarks>
+            <para>
+            Create a new ProtectCloseTextWriter using a writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Attach(System.IO.TextWriter)">
+            <summary>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to attach to</param>
+            <remarks>
+            <para>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Close">
+            <summary>
+            Does not close the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Does not close the underlying output writer.
+            This method does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReaderWriterLock">
+            <summary>
+            Defines a lock that supports single writers and multiple readers
+            </summary>
+            <remarks>
+            <para>
+            <c>ReaderWriterLock</c> is used to synchronize access to a resource. 
+            At any given time, it allows either concurrent read access for 
+            multiple threads, or write access for a single thread. In a 
+            situation where a resource is changed infrequently, a 
+            <c>ReaderWriterLock</c> provides better throughput than a simple 
+            one-at-a-time lock, such as <see cref="T:System.Threading.Monitor"/>.
+            </para>
+            <para>
+            If a platform does not support a <c>System.Threading.ReaderWriterLock</c> 
+            implementation then all readers and writers are serialized. Therefore 
+            the caller must not rely on multiple simultaneous readers.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReaderWriterLock"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireReaderLock">
+            <summary>
+            Acquires a reader lock
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.AcquireReaderLock"/> blocks if a different thread has the writer 
+            lock, or if at least one thread is waiting for the writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock">
+            <summary>
+            Decrements the lock count
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock"/> decrements the lock count. When the count 
+            reaches zero, the lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireWriterLock">
+            <summary>
+            Acquires the writer lock
+            </summary>
+            <remarks>
+            <para>
+            This method blocks if another thread has a reader lock or writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseWriterLock">
+            <summary>
+            Decrements the lock count on the writer lock
+            </summary>
+            <remarks>
+            <para>
+            ReleaseWriterLock decrements the writer lock count. 
+            When the count reaches zero, the writer lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReusableStringWriter">
+            <summary>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.
+            This uses a single buffer for string operations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </summary>
+            <param name="formatProvider">the format provider to use</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">
+            <summary>
+            Override Dispose to prevent closing of writer
+            </summary>
+            <param name="disposing">flag</param>
+            <remarks>
+            <para>
+            Override Dispose to prevent closing of writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">
+            <summary>
+            Reset this string writer so that it can be reused.
+            </summary>
+            <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>
+            <param name="defaultSize">the default size to make the buffer</param>
+            <remarks>
+            <para>
+            Reset this string writer so that it can be reused.
+            The internal buffers are cleared and reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemInfo">
+            <summary>
+            Utility class for system specific information.
+            </summary>
+            <remarks>
+            <para>
+            Utility class of static methods for system specific information.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Alexey Solofnenko</author>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#ctor">
+            <summary>
+            Private constructor to prevent instances.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#cctor">
+            <summary>
+            Initialize default values for private static fields.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyLocationInfo(System.Reflection.Assembly)">
+            <summary>
+            Gets the assembly location path for the specified assembly.
+            </summary>
+            <param name="myAssembly">The assembly to get the location for.</param>
+            <returns>The location of the assembly.</returns>
+            <remarks>
+            <para>
+            This method does not guarantee to return the correct path
+            to the assembly. If only tries to give an indication as to
+            where the assembly was loaded from.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyQualifiedName(System.Type)">
+            <summary>
+            Gets the fully qualified name of the <see cref="T:System.Type"/>, including 
+            the name of the assembly from which the <see cref="T:System.Type"/> was 
+            loaded.
+            </summary>
+            <param name="type">The <see cref="T:System.Type"/> to get the fully qualified name for.</param>
+            <returns>The fully qualified name for the <see cref="T:System.Type"/>.</returns>
+            <remarks>
+            <para>
+            This is equivalent to the <c>Type.AssemblyQualifiedName</c> property,
+            but this method works on the .NET Compact Framework 1.0 as well as
+            the full .NET runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyShortName(System.Reflection.Assembly)">
+            <summary>
+            Gets the short name of the <see cref="T:System.Reflection.Assembly"/>.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the name for.</param>
+            <returns>The short name of the <see cref="T:System.Reflection.Assembly"/>.</returns>
+            <remarks>
+            <para>
+            The short name of the assembly is the <see cref="P:System.Reflection.Assembly.FullName"/> 
+            without the version, culture, or public key. i.e. it is just the 
+            assembly's file name without the extension.
+            </para>
+            <para>
+            Use this rather than <c>Assembly.GetName().Name</c> because that
+            is not available on the Compact Framework.
+            </para>
+            <para>
+            Because of a FileIOPermission security demand we cannot do
+            the obvious Assembly.GetName().Name. We are allowed to get
+            the <see cref="P:System.Reflection.Assembly.FullName"/> of the assembly so we 
+            start from there and strip out just the assembly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyFileName(System.Reflection.Assembly)">
+            <summary>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the file name for.</param>
+            <returns>The file name of the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Type,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeType">A sibling type to use to load the type.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified, it will be loaded from the assembly
+            containing the specified relative type. If the type is not found in the assembly 
+            then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>		
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the
+            assembly that is directly calling this method. If the type is not found 
+            in the assembly then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Reflection.Assembly,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeAssembly">An assembly to load the type from.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the specified
+            assembly. If the type is not found in the assembly then all the loaded assemblies 
+            will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.NewGuid">
+            <summary>
+            Generate a new guid
+            </summary>
+            <returns>A new Guid</returns>
+            <remarks>
+            <para>
+            Generate a new guid
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateArgumentOutOfRangeException(System.String,System.Object,System.String)">
+            <summary>
+            Create an <see cref="T:System.ArgumentOutOfRangeException"/>
+            </summary>
+            <param name="parameterName">The name of the parameter that caused the exception</param>
+            <param name="actualValue">The value of the argument that causes this exception</param>
+            <param name="message">The message that describes the error</param>
+            <returns>the ArgumentOutOfRangeException object</returns>
+            <remarks>
+            <para>
+            Create a new instance of the <see cref="T:System.ArgumentOutOfRangeException"/> class 
+            with a specified error message, the parameter name, and the value 
+            of the argument.
+            </para>
+            <para>
+            The Compact Framework does not support the 3 parameter constructor for the
+            <see cref="T:System.ArgumentOutOfRangeException"/> type. This method provides an
+            implementation that works for all platforms.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int32@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int32"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int64@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int64"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int16@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int16"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetAppSetting(System.String)">
+            <summary>
+            Lookup an application setting
+            </summary>
+            <param name="key">the application settings key to lookup</param>
+            <returns>the value for the key, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Configuration APIs are not supported under the Compact Framework
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified local file path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            <para>
+            The path specified must be a local file path, a URI is not supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateCaseInsensitiveHashtable">
+            <summary>
+            Creates a new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity. 
+            </summary>
+            <returns>A new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity</returns>
+            <remarks>
+            <para>
+            The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.EqualsIgnoringCase(System.String,System.String)">
+            <summary>
+            Tests two strings for equality, the ignoring case.
+            </summary>
+            <remarks>
+            If the platform permits, culture information is ignored completely (ordinal comparison).
+            The aim of this method is to provide a fast comparison that deals with <c>null</c> and ignores different casing.
+            It is not supposed to deal with various, culture-specific habits.
+            Use it to compare against pure ASCII constants, like keywords etc.
+            </remarks>
+            <param name="a">The one string.</param>
+            <param name="b">The other string.</param>
+            <returns><c>true</c> if the strings are equal, <c>false</c> otherwise.</returns>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.EmptyTypes">
+            <summary>
+            Gets an empty array of types.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Type.EmptyTypes</c> field is not available on
+            the .NET Compact Framework 1.0.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.declaringType">
+            <summary>
+            The fully qualified type of the SystemInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_hostName">
+            <summary>
+            Cache the host name for the current machine
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_appFriendlyName">
+            <summary>
+            Cache the application friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_nullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_notAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_processStartTimeUtc">
+            <summary>
+            Start time for the current process.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NewLine">
+            <summary>
+            Gets the system dependent line terminator.
+            </summary>
+            <value>
+            The system dependent line terminator.
+            </value>
+            <remarks>
+            <para>
+            Gets the system dependent line terminator.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationBaseDirectory">
+            <summary>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The base directory path for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ConfigurationFileLocation">
+            <summary>
+            Gets the path to the configuration file for the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the configuration file for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            The .NET Compact Framework 1.0 does not have a concept of a configuration
+            file. For this runtime, we use the entry assembly location as the root for
+            the configuration file name.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.EntryAssemblyLocation">
+            <summary>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the entry assembly.</value>
+            <remarks>
+            <para>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.CurrentThreadId">
+            <summary>
+            Gets the ID of the current thread.
+            </summary>
+            <value>The ID of the current thread.</value>
+            <remarks>
+            <para>
+            On the .NET framework, the <c>AppDomain.GetCurrentThreadId</c> method
+            is used to obtain the thread ID for the current thread. This is the 
+            operating system ID for the thread.
+            </para>
+            <para>
+            On the .NET Compact Framework 1.0 it is not possible to get the 
+            operating system thread ID for the current thread. The native method 
+            <c>GetCurrentThreadId</c> is implemented inline in a header file
+            and cannot be called.
+            </para>
+            <para>
+            On the .NET Framework 2.0 the <c>Thread.ManagedThreadId</c> is used as this
+            gives a stable id unrelated to the operating system thread ID which may 
+            change if the runtime is using fibers.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.HostName">
+            <summary>
+            Get the host name or machine name for the current machine
+            </summary>
+            <value>
+            The hostname or machine name
+            </value>
+            <remarks>
+            <para>
+            Get the host name or machine name for the current machine
+            </para>
+            <para>
+            The host name (<see cref="M:System.Net.Dns.GetHostName"/>) or
+            the machine name (<c>Environment.MachineName</c>) for
+            the current machine, or if neither of these are available
+            then <c>NOT AVAILABLE</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationFriendlyName">
+            <summary>
+            Get this application's friendly name
+            </summary>
+            <value>
+            The friendly name of this application as a string
+            </value>
+            <remarks>
+            <para>
+            If available the name of the application is retrieved from
+            the <c>AppDomain</c> using <c>AppDomain.CurrentDomain.FriendlyName</c>.
+            </para>
+            <para>
+            Otherwise the file name of the entry assembly is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTime">
+            <summary>
+            Get the start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTimeUtc">
+            <summary>
+            Get the UTC start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the UTC time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+            <remarks>
+            <para>
+            Use this value to indicate a <c>null</c> has been encountered while
+            outputting a string representation of an item.
+            </para>
+            <para>
+            The default value is <c>(null)</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NullText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NotAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+            <remarks>
+            <para>
+            Use this value when an unsupported feature is requested.
+            </para>
+            <para>
+            The default value is <c>NOT AVAILABLE</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NotAvailableText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemStringFormat">
+            <summary>
+            Utility class that represents a format string.
+            </summary>
+            <remarks>
+            <para>
+            Utility class that represents a format string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.#ctor(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Initialise the <see cref="T:log4net.Util.SystemStringFormat"/>
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.ToString">
+            <summary>
+            Format the string and arguments
+            </summary>
+            <returns>the formatted string</returns>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Replaces the format item in a specified <see cref="T:System.String"/> with the text equivalent 
+            of the value of a corresponding <see cref="T:System.Object"/> instance in a specified array.
+            A specified parameter supplies culture-specific formatting information.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+            <returns>
+            A copy of format in which the format items have been replaced by the <see cref="T:System.String"/> 
+            equivalent of the corresponding instances of <see cref="T:System.Object"/> in args.
+            </returns>
+            <remarks>
+            <para>
+            This method does not throw exceptions. If an exception thrown while formatting the result the
+            exception and arguments are returned in the result string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormatError(System.Exception,System.String,System.Object[])">
+            <summary>
+            Process an error during StringFormat
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderArray(System.Array,System.Text.StringBuilder)">
+            <summary>
+            Dump the contents of an array into a string builder
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderObject(System.Object,System.Text.StringBuilder)">
+            <summary>
+            Dump an object to a string
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemStringFormat.declaringType">
+            <summary>
+            The fully qualified type of the SystemStringFormat class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextProperties._dictionary">
+            <summary>
+            Each thread will automatically have its instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove a property
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetKeys">
+            <summary>
+            Get the keys stored in the properties.
+            </summary>
+            <para>
+            Gets the keys stored in the properties.
+            </para>
+            <returns>a set of the defined keys</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Clear">
+            <summary>
+            Clear all properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the <c>PropertiesDictionary</c> for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this tread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.ThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.ThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.ThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameStack">
+            <summary>
+            The ThreadContextStack internal stack
+            </summary>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.#ctor(System.Collections.Stack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.Transform">
+            <summary>
+            Utility class for transforming strings.
+            </summary>
+            <remarks>
+            <para>
+            Utility class for transforming strings.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.Transform.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.Transform"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.WriteEscapedXmlString(System.Xml.XmlWriter,System.String,System.String)">
+            <summary>
+            Write a string to an <see cref="T:System.Xml.XmlWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="textData">the string to write</param>
+            <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param>
+            <remarks>
+            <para>
+            The test is escaped either using XML escape entities
+            or using CDATA sections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.MaskXmlInvalidCharacters(System.String,System.String)">
+            <summary>
+            Replace invalid XML characters in text string
+            </summary>
+            <param name="textData">the XML text input string</param>
+            <param name="mask">the string to use in place of invalid characters</param>
+            <returns>A string that does not contain invalid XML characters.</returns>
+            <remarks>
+            <para>
+            Certain Unicode code points are not allowed in the XML InfoSet, for
+            details see: <a href="http://www.w3.org/TR/REC-xml/#charsets">http://www.w3.org/TR/REC-xml/#charsets</a>.
+            </para>
+            <para>
+            This method replaces any illegal characters in the input string
+            with the mask string specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.CountSubstrings(System.String,System.String)">
+            <summary>
+            Count the number of times that the substring occurs in the text
+            </summary>
+            <param name="text">the text to search</param>
+            <param name="substring">the substring to find</param>
+            <returns>the number of times the substring occurs in the text</returns>
+            <remarks>
+            <para>
+            The substring is assumed to be non repeating within itself.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.Transform.INVALIDCHARS">
+            <summary>
+            Characters illegal in XML 1.0
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext">
+            <summary>
+            Impersonate a Windows Account
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.SecurityContext"/> impersonates a Windows account.
+            </para>
+            <para>
+            How the impersonation is done depends on the value of <see cref="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)"/>.
+            This allows the context to either impersonate a set of user credentials specified 
+            using username, domain name and password or to revert to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.ActivateOptions">
+            <summary>
+            Initialize the SecurityContext based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The security context will try to Logon the specified user account and
+            capture a primary token for impersonation.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, 
+            <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> or <see cref="P:log4net.Util.WindowsSecurityContext.Password"/> properties were not specified.</exception>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.
+            </summary>
+            <param name="state">caller provided state</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> instance that will revoke the impersonation of this SecurityContext
+            </returns>
+            <remarks>
+            <para>
+            Depending on the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property either
+            impersonate a user using credentials supplied or revert 
+            to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.LogonUser(System.String,System.String,System.String)">
+            <summary>
+            Create a <see cref="T:System.Security.Principal.WindowsIdentity"/> given the userName, domainName and password.
+            </summary>
+            <param name="userName">the user name</param>
+            <param name="domainName">the domain name</param>
+            <param name="password">the password</param>
+            <returns>the <see cref="T:System.Security.Principal.WindowsIdentity"/> for the account specified</returns>
+            <remarks>
+            <para>
+            Uses the Windows API call LogonUser to get a principal token for the account. This
+            token is used to initialize the WindowsIdentity.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Credentials">
+            <summary>
+            Gets or sets the impersonation mode for this security context
+            </summary>
+            <value>
+            The impersonation mode for this security context
+            </value>
+            <remarks>
+            <para>
+            Impersonate either a user with user credentials or
+            revert this thread to the credentials of the process.
+            The value is one of the <see cref="T:log4net.Util.WindowsSecurityContext.ImpersonationMode"/>
+            enum.
+            </para>
+            <para>
+            The default value is <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            the user's credentials are established using the
+            <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.Password"/>
+            values.
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process"/>
+            no other properties need to be set. If the calling thread is 
+            impersonating then it will be reverted back to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.UserName">
+            <summary>
+            Gets or sets the Windows username for this security context
+            </summary>
+            <value>
+            The Windows username for this security context
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.DomainName">
+            <summary>
+            Gets or sets the Windows domain name for this security context
+            </summary>
+            <value>
+            The Windows domain name for this security context
+            </value>
+            <remarks>
+            <para>
+            The default value for <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> is the local machine name
+            taken from the <see cref="P:System.Environment.MachineName"/> property.
+            </para>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Password">
+            <summary>
+            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.
+            </summary>
+            <value>
+            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.
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.ImpersonationMode">
+            <summary>
+            The impersonation modes for the <see cref="T:log4net.Util.WindowsSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            See the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property for
+            details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User">
+            <summary>
+            Impersonate a user using the credentials supplied
+            </summary>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process">
+            <summary>
+            Revert this the thread to the credentials of the process
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext">
+            <summary>
+            Adds <see cref="T:System.IDisposable"/> to <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Helper class to expose the <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            through the <see cref="T:System.IDisposable"/> interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.#ctor(System.Security.Principal.WindowsImpersonationContext)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="impersonationContext">the impersonation context being wrapped</param>
+            <remarks>
+            <para>
+            Constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.Dispose">
+            <summary>
+            Revert the impersonation
+            </summary>
+            <remarks>
+            <para>
+            Revert the impersonation
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.GlobalContext">
+            <summary>
+            The log4net Global Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>GlobalContext</c> provides a location for global debugging 
+            information to be stored.
+            </para>
+            <para>
+            The global context has a properties map and these properties can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputing these properties.
+            </para>
+            <para>
+            By default the <c>log4net:HostName</c> property is set to the name of 
+            the current machine.
+            </para>
+            </remarks>
+            <example>
+            <code lang="C#">
+            GlobalContext.Properties["hostname"] = Environment.MachineName;
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.GlobalContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="F:log4net.GlobalContext.s_properties">
+            <summary>
+            The global context properties instance
+            </summary>
+        </member>
+        <member name="P:log4net.GlobalContext.Properties">
+            <summary>
+            The global properties map.
+            </summary>
+            <value>
+            The global properties map.
+            </value>
+            <remarks>
+            <para>
+            The global properties map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.AssemblyInfo">
+            <summary>
+            Provides information about the environment the assembly has
+            been built for.
+            </summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.Version">
+            <summary>Version of the assembly</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFrameworkVersion">
+            <summary>Version of the framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFramework">
+            <summary>Type of framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.ClientProfile">
+            <summary>Does it target a client profile?</summary>
+        </member>
+        <member name="P:log4net.AssemblyInfo.Info">
+            <summary>
+            Identifies the version and target for this assembly.
+            </summary>
+        </member>
+        <member name="T:log4net.LogicalThreadContext">
+            <summary>
+            The log4net Logical Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> provides a location for <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> specific debugging 
+            information to be stored.
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> or <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The Logical Thread Context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Logical Thread Context provides a diagnostic context for the current call context. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Logical Thread Context is managed on a per <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> basis.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            LogicalThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a LogicalThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.LogicalThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> 
+            or <see cref="T:log4net.GlobalContext"/> properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The logical thread stacks.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.LogManager">
+            <summary>
+            This class is used by client applications to request logger instances.
+            </summary>
+            <remarks>
+            <para>
+            This class has static methods that are used by a client to request
+            a logger instance. The <see cref="M:GetLogger(string)"/> method is 
+            used to retrieve a logger.
+            </para>
+            <para>
+            See the <see cref="T:log4net.ILog"/> interface for more details.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <seealso cref="T:log4net.ILog"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.LogManager.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.LogManager"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String)">
+            <overloads>Returns the named logger if it exists.</overloads>
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the default repository) then it
+            returns a reference to the logger, otherwise it returns <c>null</c>.
+            </para>
+            </remarks>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>The logger found, or <c>null</c> if no logger could be found.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers">
+            <overloads>Get the currently defined loggers.</overloads>
+            <summary>
+            Returns all the currently defined loggers in the default repository.
+            </summary>
+            <remarks>
+            <para>The root logger is <b>not</b> included in the returned array.</para>
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String)">
+            <overloads>Get or create a logger.</overloads>
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the logger doesn't exist in the specified 
+            repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the repository for the specified assembly) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger, or <c>null</c> if the logger doesn't exist in the specified
+            assembly's repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Get the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository">
+            <overloads>Shutdown a logger repository.</overloads>
+            <summary>
+            Shuts down the default repository.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            default repository.
+            </para>
+            <para>Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repository">The repository to shutdown.</param>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration">
+            <overloads>Reset the configuration of a repository</overloads>
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repository">The repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository">
+            <overloads>Get the logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository">
+            <overloads>Get a logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Type)">
+            <overloads>Create a domain</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Type)">
+            <overloads>Create a logger repository.</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetAllRepositories">
+            <summary>
+            Gets the list of currently defined repositories.
+            </summary>
+            <remarks>
+            <para>
+            Get an array of all the <see cref="T:log4net.Repository.ILoggerRepository"/> objects that have been created.
+            </para>
+            </remarks>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Flush(System.Int32)">
+            <summary>
+            Flushes logging events buffered in all configured appenders in the default repository.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLogger(log4net.Core.ILogger)">
+            <summary>
+            Looks up the wrapper object for the logger specified.
+            </summary>
+            <param name="logger">The logger to get the wrapper for.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLoggers(log4net.Core.ILogger[])">
+            <summary>
+            Looks up the wrapper objects for the loggers specified.
+            </summary>
+            <param name="loggers">The loggers to get the wrappers for.</param>
+            <returns>The wrapper objects for the loggers specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapperCreationHandler(log4net.Core.ILogger)">
+            <summary>
+            Create the <see cref="T:log4net.Core.ILoggerWrapper"/> objects used by
+            this manager.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="F:log4net.LogManager.s_wrapperMap">
+            <summary>
+            The wrapper map to use to hold the <see cref="T:log4net.Core.LogImpl"/> objects.
+            </summary>
+        </member>
+        <member name="T:log4net.MDC">
+            <summary>
+            Implementation of Mapped Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is
+            based on a map instead of a stack. It provides <i>mapped
+            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or
+            MDC in short, is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The MDC is managed on a per thread basis.
+            </para>
+            </remarks>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.MDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.MDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Get(System.String)">
+            <summary>
+            Gets the context value identified by the <paramref name="key"/> parameter.
+            </summary>
+            <param name="key">The key to lookup in the MDC.</param>
+            <returns>The string value held for the key, or a <c>null</c> reference if no corresponding value is found.</returns>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            If the <paramref name="key"/> parameter does not look up to a
+            previously defined context then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Set(System.String,System.String)">
+            <summary>
+            Add an entry to the MDC
+            </summary>
+            <param name="key">The key to store the value under.</param>
+            <param name="value">The value to store.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Puts a context value (the <paramref name="value"/> parameter) as identified
+            with the <paramref name="key"/> parameter into the current thread's
+            context map.
+            </para>
+            <para>
+            If a value is already defined for the <paramref name="key"/>
+            specified then the value will be replaced. If the <paramref name="value"/> 
+            is specified as <c>null</c> then the key value mapping will be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Remove(System.String)">
+            <summary>
+            Removes the key value mapping for the key specified.
+            </summary>
+            <param name="key">The key to remove.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove the specified entry from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Clear">
+            <summary>
+            Clear all entries in the MDC
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove all the entries from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.NDC">
+            <summary>
+            Implementation of Nested Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            A Nested Diagnostic Context, or NDC in short, is an instrument
+            to distinguish interleaved log output from different sources. Log
+            output is typically interleaved when a server handles multiple
+            clients near-simultaneously.
+            </para>
+            <para>
+            Interleaved log output can still be meaningful if each log entry
+            from different contexts had a distinctive stamp. This is where NDCs
+            come into play.
+            </para>
+            <para>
+            Note that NDCs are managed on a per thread basis. The NDC class
+            is made up of static methods that operate on the context of the
+            calling thread.
+            </para>
+            </remarks>
+            <example>How to push a message into the context
+            <code lang="C#">
+            using(NDC.Push("my context message"))
+            {
+            	... all log calls will have 'my context message' included ...
+            
+            } // at the end of the using block the message is automatically removed 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.NDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.NDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Clear">
+            <summary>
+            Clears all the contextual information held on the current thread.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Clears the stack of NDC data held on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.CloneStack">
+            <summary>
+            Creates a clone of the stack of context information.
+            </summary>
+            <returns>A clone of the context info for this thread.</returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The results of this method can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> 
+            method to allow child threads to inherit the context of their 
+            parent thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">
+            <summary>
+            Inherits the contextual information from another thread.
+            </summary>
+            <param name="stack">The context stack to inherit.</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This thread will use the context information from the stack
+            supplied. This can be used to initialize child threads with
+            the same contextual information as their parent threads. These
+            contexts will <b>NOT</b> be shared. Any further contexts that
+            are pushed onto the stack will not be visible to the other.
+            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to
+            this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Pop">
+            <summary>
+            Removes the top context from the stack.
+            </summary>
+            <returns>
+            The message in the context that was removed from the top 
+            of the stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Remove the top context from the stack, and return
+            it to the caller. If the stack is empty then an
+            empty string (not <c>null</c>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Push(System.String)">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.NDC.Push("NDC_Message"))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.PushFormat(System.String,System.Object[])">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="messageFormat">The new context message string format.</param>
+            <param name="args">Arguments to be passed into messageFormat.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            var someValue = "ExampleContext"
+            using(log4net.NDC.PushFormat("NDC_Message {0}", someValue))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.Remove">
+            <summary>
+            Removes the context information for this thread. It is
+            not required to call this method.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This method is not implemented.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">
+            <summary>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            </summary>
+            <param name="maxDepth">The maximum depth of the stack</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            This may truncate the head of the stack. This only affects the 
+            stack in the current thread. Also it does not prevent it from
+            growing, it only sets the maximum depth at the time of the
+            call. This can be used to return to a known context depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.NDC.Depth">
+            <summary>
+            Gets the current context depth.
+            </summary>
+            <value>The current context depth.</value>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The number of context values pushed onto the context stack.
+            </para>
+            <para>
+            Used to record the current depth of the context. This can then 
+            be restored using the <see cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/> method.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/>
+        </member>
+        <member name="T:log4net.ThreadContext">
+            <summary>
+            The log4net Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> provides a location for thread specific debugging 
+            information to be stored.
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            The thread context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Thread Context provides a diagnostic context for the current thread. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Thread Context is managed on a per thread basis.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            ThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a ThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(ThreadContext.Stacks["NDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a ThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.ThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.ThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.ThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.ThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The thread local stacks.
+            </para>
+            </remarks>
+        </member>
+    </members>
+</doc>
diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net45-full/log4net.dll b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net45-full/log4net.dll
new file mode 100644
index 0000000000000000000000000000000000000000..93fb476ce09698c5b42da2596d74de0cfdbd1c81
GIT binary patch
literal 276480
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

literal 0
HcmV?d00001

diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/net45-full/log4net.xml b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net45-full/log4net.xml
new file mode 100644
index 000000000..18f17674e
--- /dev/null
+++ b/AYA.SlnSynor/packages/log4net.2.0.8/lib/net45-full/log4net.xml
@@ -0,0 +1,32464 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>log4net</name>
+    </assembly>
+    <members>
+        <member name="T:log4net.Appender.AdoNetAppender">
+            <summary>
+            Appender that logs to a database.
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
+            database. The appender can be configured to specify the connection 
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
+            property. For more information on database connection strings for
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
+            </para>
+            <para>
+            Records are written into the database either using a prepared
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
+            procedure.
+            </para>
+            <para>
+            The prepared statement text or the name of the stored procedure
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
+            </para>
+            <para>
+            The prepared statement or stored procedure can take a number
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
+            type may be subclassed if required to provide database specific
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
+            the parameter name, database type, size, and how the value should
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
+            </para>
+            </remarks>
+            <example>
+            An example of a SQL Server table that could be logged to:
+            <code lang="SQL">
+            CREATE TABLE [dbo].[Log] ( 
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,
+              [Date] [datetime] NOT NULL ,
+              [Thread] [varchar] (255) NOT NULL ,
+              [Level] [varchar] (20) NOT NULL ,
+              [Logger] [varchar] (255) NOT NULL ,
+              [Message] [varchar] (4000) NOT NULL 
+            ) ON [PRIMARY]
+            </code>
+            </example>
+            <example>
+            An example configuration to log to the above table:
+            <code lang="XML" escaped="true">
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
+              <parameter>
+                <parameterName value="@log_date"/>
+                <dbType value="DateTime"/>
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@thread"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@log_level"/>
+                <dbType value="String"/>
+                <size value="50"/>
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@logger"/>
+                <dbType value="String"/>
+                <size value="255"/>
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
+              </parameter>
+              <parameter>
+                <parameterName value="@message"/>
+                <dbType value="String"/>
+                <size value="4000"/>
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>
+              </parameter>
+            </appender>
+            </code>
+            </example>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Lance Nehring</author>
+        </member>
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
+            buffers events in a fixed size buffer.
+            </summary>
+            <remarks>
+            <para>
+            This base class should be used by appenders that need to buffer a 
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            buffers events and then submits the entire contents of the buffer to 
+            the underlying database in one go.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:SendBuffer(LoggingEvent[])"/>
+            method to deliver the buffered events.
+            </para>
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
+            buffer of events. The size of the buffer is set using 
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
+            </para>
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
+            triggers, then the current buffer is sent immediately 
+            (see <see cref="M:SendBuffer(LoggingEvent[])"/>). Otherwise the event 
+            is stored in the buffer. For example, an evaluator can be used to 
+            deliver the events immediately when an ERROR event arrives.
+            </para>
+            <para>
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
+            By default the appender is NOT lossy. When the buffer is full all 
+            the buffered events are sent with <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
+            buffer will not be sent when it is full, and new events arriving 
+            in the appender will overwrite the oldest event in the buffer. 
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
+            triggers. This can be useful behavior when you need to know about 
+            ERROR events but not about events with a lower level, configure an 
+            evaluator that will trigger when an ERROR event arrives, the whole 
+            buffer will be sent which gives a history of events leading up to
+            the ERROR event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.AppenderSkeleton">
+            <summary>
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
+            </summary>
+            <remarks>
+            <para>
+            This class provides the code for common functionality, such 
+            as support for threshold filtering and support for general filters.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Appender.IAppender">
+            <summary>
+            Implement this interface for your own strategies for printing log statements.
+            </summary>
+            <remarks>
+            <para>
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
+            class which provides a default implementation of this interface.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.IAppender.Close">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logging event in Appender specific way.
+            </summary>
+            <param name="loggingEvent">The event to log</param>
+            <remarks>
+            <para>
+            This method is called to log a message into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.IAppender.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>The name uniquely identifies the appender.</para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IBulkAppender">
+            <summary>
+            Interface for appenders that support bulk logging.
+            </summary>
+            <remarks>
+            <para>
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
+            should only implement this interface if they can bulk log efficiently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Log the array of logging events in Appender specific way.
+            </summary>
+            <param name="loggingEvents">The events to log</param>
+            <remarks>
+            <para>
+            This method is called to log an array of events into this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IOptionHandler">
+            <summary>
+            Interface used to delay activate a configured object.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
+            must be called by the container after its all the configured properties have been set 
+            and before the component can be used.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
+            <summary>
+            Activate the options that were previously set with calls to properties.
+            </summary>
+            <remarks>
+            <para>
+            This allows an object to defer activation of its options until all
+            options have been set. This is required for components which have
+            related options that remain ambiguous until all are set.
+            </para>
+            <para>
+            If a component implements this interface then this method must be called
+            after its properties have been set before the component can be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.IFlushable">
+            <summary>
+            Interface that can be implemented by Appenders that buffer logging data and expose a <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.IFlushable.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            Appenders that implement the <see cref="M:log4net.Appender.IFlushable.Flush(System.Int32)"/> method must do so in a thread-safe manner: it can be called concurrently with
+            the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            <para>
+            Typically this is done by locking on the Appender instance, e.g.:
+            <code>
+            <![CDATA[
+            public bool Flush(int millisecondsTimeout)
+            {
+                lock(this)
+                {
+                    // Flush buffered logging data
+                    ...
+                }
+            }
+            ]]>
+            </code>
+            </para>
+            <para>
+            The <paramref name="millisecondsTimeout"/> parameter is only relevant for appenders that process logging events asynchronously,
+            such as <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            </remarks>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>Empty default constructor</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
+            <summary>
+            Finalizes this appender by calling the implementation's 
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
+            </summary>
+            <remarks>
+            <para>
+            If this appender has not been closed then the <c>Finalize</c> method
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">
+            <summary>
+            Closes the appender and release resources.
+            </summary>
+            <remarks>
+            <para>
+            Release any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            <para>
+            This method cannot be overridden by subclasses. This method 
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
+            method which must be overridden in the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent)"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>
+            will be passed to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
+            <summary>
+            Performs threshold checks and invokes filters before 
+            delegating actual logging to the subclasses specific 
+            <see cref="M:Append(LoggingEvent[])"/> method.
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method cannot be overridden by derived classes. A
+            derived class should override the <see cref="M:Append(LoggingEvent[])"/> method
+            which is called by this method.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvents"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvents"/>.
+            		</description>
+            	</item>
+            	<item>
+            		<description>
+            		Calls <see cref="M:PreAppendCheck()"/> and checks that 
+            		it returns <c>true</c>.</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>
+            will be passed to the <see cref="M:Append(LoggingEvent[])"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if the logging event should we output by this appender
+            </summary>
+            <param name="loggingEvent">the event to test</param>
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
+            <remarks>
+            <para>
+            This method checks the logging event against the threshold level set
+            on this appender and also against the filters specified on this
+            appender.
+            </para>
+            <para>
+            The implementation of this method is as follows:
+            </para>
+            <para>
+            <list type="bullet">
+            	<item>
+            		<description>
+            		Checks that the severity of the <paramref name="loggingEvent"/>
+            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
+            		appender.</description>
+            	</item>
+            	<item>
+            		<description>
+            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
+            		<paramref name="loggingEvent"/>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
+            <summary>
+            Adds a filter to the end of the filter chain.
+            </summary>
+            <param name="filter">the filter to add to this appender</param>
+            <remarks>
+            <para>
+            The Filters are organized in a linked list.
+            </para>
+            <para>
+            Setting this property causes the new filter to be pushed onto the 
+            back of the filter chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
+            <summary>
+            Clears the filter list for this appender.
+            </summary>
+            <remarks>
+            <para>
+            Clears the filter list for this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
+            <summary>
+            Checks if the message level is below this appender's threshold.
+            </summary>
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
+            <remarks>
+            <para>
+            If there is no threshold set, then the return value is always <c>true</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
+            requirements of this appender.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
+            <summary>
+            Is called when the appender is closed. Derived classes should override 
+            this method if resources need to be released.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
+            to perform actual logging.
+            </summary>
+            <param name="loggingEvent">The event to append.</param>
+            <remarks>
+            <para>
+            A subclass must implement this method to perform
+            logging of the <paramref name="loggingEvent"/>.
+            </para>
+            <para>This method will be called by <see cref="M:DoAppend(LoggingEvent)"/>
+            if all the conditions listed for that method are met.
+            </para>
+            <para>
+            To restrict the logging of events in the appender
+            override the <see cref="M:PreAppendCheck()"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append a bulk array of logging events.
+            </summary>
+            <param name="loggingEvents">the array of logging events</param>
+            <remarks>
+            <para>
+            This base class implementation calls the <see cref="M:Append(LoggingEvent)"/>
+            method for each element in the bulk array.
+            </para>
+            <para>
+            A sub class that can better process a bulk array of events should
+            override this method in addition to <see cref="M:Append(LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
+            <summary>
+            Called before <see cref="M:Append(LoggingEvent)"/> as a precondition.
+            </summary>
+            <remarks>
+            <para>
+            This method is called by <see cref="M:DoAppend(LoggingEvent)"/>
+            before the call to the abstract <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            This method can be overridden in a subclass to extend the checks 
+            made before the event is passed to the <see cref="M:Append(LoggingEvent)"/> method.
+            </para>
+            <para>
+            A subclass should ensure that they delegate this call to
+            this base class if it is overridden.
+            </para>
+            </remarks>
+            <returns><c>true</c> if the call to <see cref="M:Append(LoggingEvent)"/> should proceed.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <returns>The event rendered as a string.</returns>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Where possible use the alternative version of this method
+            <see cref="M:RenderLoggingEvent(TextWriter,LoggingEvent)"/>.
+            That method streams the rendering onto an existing Writer
+            which can give better performance if the caller already has
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
+            </summary>
+            <param name="loggingEvent">The event to render.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
+            set to render the <paramref name="loggingEvent"/> to 
+            a string.
+            </para>
+            <para>If there is exception data in the logging event and 
+            the layout does not process the exception, this method 
+            will append the exception text to the rendered string.
+            </para>
+            <para>
+            Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>
+            where possible. If, however, the caller needs to render the event
+            to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does
+            provide an efficient mechanism for doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <remarks>
+            This implementation doesn't flush anything and always returns true
+            </remarks>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
+            <summary>
+            The layout of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
+            <summary>
+            The name of this appender.
+            </summary>
+            <remarks>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
+            <summary>
+            The level threshold of this appender.
+            </summary>
+            <remarks>
+            <para>
+            There is no level threshold filtering by default.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
+            <summary>
+            It is assumed and enforced that errorHandler is never null.
+            </summary>
+            <remarks>
+            <para>
+            It is assumed and enforced that errorHandler is never null.
+            </para>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
+            <summary>
+            The first filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            Set to <c>null</c> initially.
+            </para>
+            <para>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
+            <summary>
+            The last filter in the filter chain.
+            </summary>
+            <remarks>
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
+            <summary>
+            Flag indicating if this appender is closed.
+            </summary>
+            <remarks>
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
+            <summary>
+            The guard prevents an appender from repeatedly calling its own DoAppend method
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
+            <summary>
+            StringWriter used to render events
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AppenderSkeleton.declaringType">
+            <summary>
+            The fully qualified type of the AppenderSkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
+            <summary>
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
+            </summary>
+            <value>
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
+            </value>
+            <remarks>
+            <para>
+            All log events with lower level than the threshold level are ignored 
+            by the appender.
+            </para>
+            <para>
+            In configuration files this option is specified by setting the
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
+            string, such as "DEBUG", "INFO" and so on.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </summary>
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
+            <summary>
+            The filter chain.
+            </summary>
+            <value>The head of the filter chain filter chain.</value>
+            <remarks>
+            <para>
+            Returns the head Filter. The Filters are organized in a linked list
+            and so all Filters on this Appender are available through the result.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
+            </summary>
+            <value>The layout of the appender.</value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">
+            <summary>
+            Gets or sets the name of this appender.
+            </summary>
+            <value>The name of the appender.</value>
+            <remarks>
+            <para>
+            The name uniquely identifies the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
+            <summary>
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <remarks>
+            <para>
+            In the rather exceptional case, where the appender 
+            implementation admits a layout but can also work without it, 
+            then the appender should return <c>true</c>.
+            </para>
+            <para>
+            This default implementation always returns <c>false</c>.
+            </para>
+            </remarks>
+            <returns>
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
+            <summary>
+            The default buffer size.
+            </summary>
+            <remarks>
+            The default size of the cyclic buffer used to store events.
+            This is set to 512 by default.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
+            </summary>
+            <param name="eventMustBeFixed">the events passed through this appender must be
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
+            <remarks>
+            <para>
+            Protected constructor to allow subclassing.
+            </para>
+            <para>
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass
+            expects the events delivered to be fixed even if the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <remarks>
+            <para>
+            Flushes any events that have been buffered.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will NOT be flushed to the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
+            <summary>
+            Flush the currently buffered events
+            </summary>
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
+            <remarks>
+            <para>
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
+            </para>
+            <para>
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
+            In this case the contents of the buffer will be tested against the 
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
+            events will be discarded.
+            </para>
+            <para>
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
+            be emptied by calling this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
+            <summary>
+            Close this appender instance.
+            </summary>
+            <remarks>
+            <para>
+            Close this appender instance. If this appender is marked
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
+            the buffer must be sent when the appender is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
+            </para>
+            <para>
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
+            method) if one of the following conditions is met:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>The cyclic buffer is full and this appender is
+            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
+            	</item>
+            	<item>
+            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
+            		it is triggered for the <paramref name="loggingEvent"/>
+            		specified.</description>
+            	</item>
+            </list>
+            <para>
+            Before the event is stored in the buffer it is fixed
+            (see <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/>) to ensure that
+            any data referenced by the event will be valid when the buffer
+            is processed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
+            <summary>
+            Sends the contents of the buffer.
+            </summary>
+            <param name="firstLoggingEvent">The first logging event.</param>
+            <param name="buffer">The buffer containing the events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override <see cref="M:SendBuffer(LoggingEvent[])"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            The subclass must override this method to process the buffered events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
+            <summary>
+            The size of the cyclic buffer used to hold the logging events.
+            </summary>
+            <remarks>
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
+            <summary>
+            The cyclic buffer used to store the logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
+            <summary>
+            The triggering event evaluator that causes the buffer to be sent immediately.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event causes the entire
+            buffer to be sent immediately. This field can be <c>null</c>, which 
+            indicates that event triggering is not to be done. The evaluator
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
+            <summary>
+            Indicates if the appender should overwrite events in the cyclic buffer 
+            when it becomes full, or if the buffer should be flushed when the 
+            buffer is full.
+            </summary>
+            <remarks>
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
+            be set.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
+            <summary>
+            The triggering event evaluator filters discarded events.
+            </summary>
+            <remarks>
+            The object that is used to determine if an event that is discarded should
+            really be discarded or if it should be sent to the appenders. 
+            This field can be <c>null</c>, which indicates that all discarded events will
+            be discarded. 
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
+            <summary>
+            The events delivered to the subclass must be fixed.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
+            <summary>
+            Gets or sets a value that indicates whether the appender is lossy.
+            </summary>
+            <value>
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            This appender uses a buffer to store logging events before 
+            delivering them. A triggering event causes the whole buffer
+            to be send to the remote sink. If the buffer overruns before
+            a triggering event then logging events could be lost. Set
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
+            from being lost.
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
+            <summary>
+            Gets or sets the size of the cyclic buffer used to hold the 
+            logging events.
+            </summary>
+            <value>
+            The size of the cyclic buffer used to hold the logging events.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
+            representing the maximum number of logging events to collect in 
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
+            oldest events are deleted as new events are added to the
+            buffer. By default the size of the cyclic buffer is 512 events.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
+            or equal to 1 then no buffering will occur. The logging event
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
+            be buffered.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
+            buffer to be sent immediately.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
+            sent immediately.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is appended to this 
+            appender. If the evaluator triggers then the current buffer will 
+            immediately be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
+            <summary>
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </summary>
+            <value>
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
+            </value>
+            <remarks>
+            <para>
+            The evaluator will be called for each event that is discarded from this 
+            appender. If the evaluator triggers then the current buffer will immediately 
+            be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating if only part of the logging event data
+            should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the
+            event data to be fixed and serialized. This will improve performance.
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
+            <summary>
+            Gets or sets a the fields that will be fixed in the event
+            </summary>
+            <value>
+            The event fields that will be fixed before the event is buffered
+            </value>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
+            <summary> 
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
+            </summary>
+            <remarks>
+            Public default constructor to initialize a new instance of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
+            <summary>
+            Override the parent method to close the database
+            </summary>
+            <remarks>
+            <para>
+            Closes the database command and database connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Inserts the events into the database.
+            </summary>
+            <param name="events">The events to insert into the database.</param>
+            <remarks>
+            <para>
+            Insert all the events specified in the <paramref name="events"/>
+            array into the database.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
+            <summary>
+            Adds a parameter to the command.
+            </summary>
+            <param name="parameter">The parameter to add to the command.</param>
+            <remarks>
+            <para>
+            Adds a parameter to the ordered list of command parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
+            <summary>
+            Writes the events to the database using the transaction specified.
+            </summary>
+            <param name="dbTran">The transaction that the events will be executed under.</param>
+            <param name="events">The array of events to insert into the database.</param>
+            <remarks>
+            <para>
+            The transaction argument can be <c>null</c> if the appender has been
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
+            property for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
+            <summary>
+            Formats the log message into database statement text.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            This method can be overridden by subclasses to provide 
+            more control over the format of the database statement.
+            </remarks>
+            <returns>
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.CreateConnection(System.Type,System.String)">
+            <summary>
+            Creates an <see cref="T:System.Data.IDbConnection"/> instance used to connect to the database.
+            </summary>
+            <remarks>
+            This method is called whenever a new IDbConnection is needed (i.e. when a reconnect is necessary).
+            </remarks>
+            <param name="connectionType">The <see cref="T:System.Type"/> of the <see cref="T:System.Data.IDbConnection"/> object.</param>
+            <param name="connectionString">The connectionString output from the ResolveConnectionString method.</param>
+            <returns>An <see cref="T:System.Data.IDbConnection"/> instance with a valid connection string.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionString(System.String@)">
+            <summary>
+            Resolves the connection string from the ConnectionString, ConnectionStringName, or AppSettingsKey
+            property.
+            </summary>
+            <remarks>
+            ConnectiongStringName is only supported on .NET 2.0 and higher.
+            </remarks>
+            <param name="connectionStringContext">Additional information describing the connection string.</param>
+            <returns>A connection string used to connect to the database.</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
+            <summary>
+            Retrieves the class type of the ADO.NET provider.
+            </summary>
+            <remarks>
+            <para>
+            Gets the Type of the ADO.NET provider to use to connect to the
+            database. This method resolves the type specified in the 
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
+            </para>
+            <para>
+            Subclasses can override this method to return a different type
+            if necessary.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
+            <summary>
+            Connects to the database.
+            </summary>		
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppender.DiposeConnection">
+            <summary>
+            Cleanup the existing connection.
+            </summary>
+            <remarks>
+            Calls the IDbConnection's <see cref="M:System.Data.IDbConnection.Close"/> method.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
+            <summary>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </summary>
+            <remarks>
+            <para>
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
+            <summary>
+            The <see cref="T:System.Data.IDbConnection"/> that will be used
+            to insert logging events into a database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
+            <summary>
+            Database connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_appSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
+            <summary>
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
+            <summary>
+            The text of the command.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
+            <summary>
+            The command type.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
+            <summary>
+            Indicates whether to use transactions when writing to the database.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
+            <summary>
+            Indicates whether to reconnect when a connection is lost.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppender.declaringType">
+            <summary>
+            The fully qualified type of the AdoNetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
+            <summary>
+            Gets or sets the database connection string that is used to connect to 
+            the database.
+            </summary>
+            <value>
+            The database connection string used to connect to the database.
+            </value>
+            <remarks>
+            <para>
+            The connections string is specific to the connection type.
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
+            </para>
+            </remarks>
+            <example>Connection string for MS Access via ODBC:
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
+            </example>
+            <example>Another connection string for MS Access via ODBC:
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
+            </example>
+            <example>Connection string for MS Access via OLE DB:
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.AppSettingsKey">
+            <summary>
+            The appSettings key from App.Config that contains the connection string.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionStringName">
+            <summary>
+            The connectionStrings key from App.Config that contains the connection string.
+            </summary>
+            <remarks>
+            This property requires at least .NET 2.0.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
+            <summary>
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
+            that should be created.
+            </summary>
+            <value>
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
+            </value>
+            <remarks>
+            <para>
+            The type name of the ADO.NET provider to use.
+            </para>
+            <para>
+            The default is to use the OLE DB provider.
+            </para>
+            </remarks>
+            <example>Use the OLE DB Provider. This is the default value.
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the MS SQL Server Provider. 
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            </example>
+            <example>Use the ODBC Provider. 
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>ODBC .NET Data Provider</b>.
+            </example>
+            <example>Use the Oracle Provider. 
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
+            This is an optional package that you can download from 
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
+            search for <b>.NET Managed Provider for Oracle</b>.
+            </example>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
+            <summary>
+            Gets or sets the command text that is used to insert logging events
+            into the database.
+            </summary>
+            <value>
+            The command text used to insert logging events into the database.
+            </value>
+            <remarks>
+            <para>
+            Either the text of the prepared statement or the
+            name of the stored procedure to execute to write into
+            the database.
+            </para>
+            <para>
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
+            this text is a prepared statement or a stored procedure.
+            </para>
+            <para>
+            If this property is not set, the command text is retrieved by invoking
+            <see cref="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
+            <summary>
+            Gets or sets the command type to execute.
+            </summary>
+            <value>
+            The command type to execute.
+            </value>
+            <remarks>
+            <para>
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
+            to execute.
+            </para>
+            <para>
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
+            <summary>
+            Should transactions be used to insert logging events in the database.
+            </summary>
+            <value>
+            <c>true</c> if transactions should be used to insert logging events in
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a value that indicates whether transactions should be used
+            to insert logging events in the database.
+            </para>
+            <para>
+            When set a single transaction will be used to insert the buffered events
+            into the database. Otherwise each event will be inserted without using
+            an explicit transaction.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
+            <summary>
+            Should this appender try to reconnect to the database on error.
+            </summary>
+            <value>
+            <c>true</c> if the appender should try to reconnect to the database after an
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
+            i.e. not to try to reconnect.
+            </value>
+            <remarks>
+            <para>
+            The default behaviour is for the appender not to try to reconnect to the
+            database if an error occurs. Subsequent logging events are discarded.
+            </para>
+            <para>
+            To force the appender to attempt to reconnect to the database set this
+            property to <c>true</c>.
+            </para>
+            <note>
+            When the appender attempts to connect to the database there may be a
+            delay of up to the connection timeout specified in the connection string.
+            This delay will block the calling application's thread. 
+            Until the connection can be reestablished this potential delay may occur multiple times.
+            </note>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Data.IDbConnection"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">
+            <summary>
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            This class provides the basic database parameter properties
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
+            </para>
+            <para>This type can be subclassed to provide database specific
+            functionality. The two methods that are called externally are
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.
+            </summary>
+            <remarks>
+            Default constructor for the AdoNetAppenderParameter class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">
+            <summary>
+            Prepare the specified database command object.
+            </summary>
+            <param name="command">The command to prepare.</param>
+            <remarks>
+            <para>
+            Prepares the database command object by adding
+            this parameter to its collection of parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">
+            <summary>
+            Renders the logging event and set the parameter value in the command.
+            </summary>
+            <param name="command">The command containing the parameter.</param>
+            <param name="loggingEvent">The event to be rendered.</param>
+            <remarks>
+            <para>
+            Renders the logging event using this parameters layout
+            object. Sets the value of the parameter on the command object.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">
+            <summary>
+            The name of this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">
+            <summary>
+            The database type for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">
+            <summary>
+            Flag to infer type rather than use the DbType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">
+            <summary>
+            The precision for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">
+            <summary>
+            The scale for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">
+            <summary>
+            The size for this parameter.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">
+            <summary>
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the
+            logging event into an object for this parameter.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">
+            <summary>
+            Gets or sets the name of this parameter.
+            </summary>
+            <value>
+            The name of this parameter.
+            </value>
+            <remarks>
+            <para>
+            The name of this parameter. The parameter name
+            must match up to a named parameter to the SQL stored procedure
+            or prepared statement.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">
+            <summary>
+            Gets or sets the database type for this parameter.
+            </summary>
+            <value>
+            The database type for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The database type for this parameter. This property should
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the type from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">
+            <summary>
+            Gets or sets the precision for this parameter.
+            </summary>
+            <value>
+            The precision for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum number of digits used to represent the Value.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the precision from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">
+            <summary>
+            Gets or sets the scale for this parameter.
+            </summary>
+            <value>
+            The scale for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The number of decimal places to which Value is resolved.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the scale from the value.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">
+            <summary>
+            Gets or sets the size for this parameter.
+            </summary>
+            <value>
+            The size for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The maximum size, in bytes, of the data within the column.
+            </para>
+            <para>
+            This property is optional. If not specified the ADO.NET provider 
+            will attempt to infer the size from the value.
+            </para>
+            <para>
+            For BLOB data types like VARCHAR(max) it may be impossible to infer the value automatically, use -1 as the size in this case.
+            </para>
+            </remarks>
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>
+        </member>
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to 
+            render the logging event into an object for this 
+            parameter.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the
+            logging event into an object for this parameter.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this
+            parameter.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>
+            for use in the property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">
+            <summary>
+            Appends logging events to the terminal using ANSI color escape sequences.
+            </summary>
+            <remarks>
+            <para>
+            AnsiColorTerminalAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific level of message to be set.
+            </para>
+            <note>
+            This appender expects the terminal to understand the VT100 control set 
+            in order to interpret the color codes. If the terminal or console does not
+            understand the control codes the behavior is not defined.
+            </note>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            <para>
+            When configuring the ANSI colored terminal appender, a mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red"/>
+                <attributes value="Bright,Underscore"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            </list>
+            These color values cannot be combined together to make new colors.
+            </para>
+            <para>
+            The attributes can be any combination of the following:
+            <list type="bullet">
+            <item><term>Bright</term><description>foreground is brighter</description></item>
+            <item><term>Dim</term><description>foreground is dimmer</description></item>
+            <item><term>Underscore</term><description>message is underlined</description></item>
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>
+            <item><term>Hidden</term><description>output is hidden</description></item>
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>
+            </list>
+            While any of these attributes may be combined together not all combinations
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes
+            no sense.
+            </para>
+            </remarks>
+            <author>Patrick Wagstrom</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">
+            <summary>
+            Ansi code to reset terminal
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colours
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">
+            <summary>
+            The enum of possible display attributes
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the ANSI color attributes.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">
+            <summary>
+            text is bright
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">
+            <summary>
+            text is dim
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">
+            <summary>
+            text is underlined
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">
+            <summary>
+            text is blinking
+            </summary>
+            <remarks>
+            Not all terminals support this attribute
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">
+            <summary>
+            text and background colors are reversed
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">
+            <summary>
+            text is hidden
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">
+            <summary>
+            text is displayed with a strikethrough
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Light">
+            <summary>
+            text color is light
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">
+            <summary>
+            The enum of possible foreground or background color values for 
+            use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The output can be in one for the following ANSI colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">
+            <summary>
+            color is black
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">
+            <summary>
+            color is magenta
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LevelMappingEntry">
+            <summary>
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract base class for types that are stored in the
+            <see cref="T:log4net.Util.LevelMapping"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">
+            <summary>
+            Default protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Default protected constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
+            <summary>
+            Initialize any options defined on this entry
+            </summary>
+            <remarks>
+            <para>
+            Should be overridden by any classes that need to initialise based on their options
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LevelMappingEntry.Level">
+            <summary>
+            The level that is the key for this mapping 
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping 
+            </value>
+            <remarks>
+            <para>
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
+            mapping subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together
+            and append the attributes.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">
+            <summary>
+            The color attributes for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The color attributes for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            An <c>AppenderCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">
+            <summary>
+            An empty readonly static AppenderCollection
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <c>AppenderCollection</c>.
+            </summary>
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>AppenderCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">
+            <summary>
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">
+            <summary>
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clear">
+            <summary>
+            Removes all elements from the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>
+            in the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">
+            <summary>
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>AppenderCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">
+            <summary>
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.
+            </summary>
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">
+            <summary>
+            Return the collection elements as an array
+            </summary>
+            <returns>the array</returns>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            	<para><paramref name="index"/> is less than zero</para>
+            	<para>-or-</para>
+            	<para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Appender.AspNetTraceAppender">
+            <summary>
+            <para>
+            Appends log events to the ASP.NET <see cref="T:System.Web.TraceContext"/> system.
+            </para>
+            </summary>
+            <remarks>
+            <para>
+            Diagnostic information and tracing messages that you specify are appended to the output 
+            of the page that is sent to the requesting browser. Optionally, you can view this information
+            from a separate trace viewer (Trace.axd) that displays trace information for every page in a 
+            given application.
+            </para>
+            <para>
+            Trace statements are processed and displayed only when tracing is enabled. You can control 
+            whether tracing is displayed to a page, to the trace viewer, or both.
+            </para>
+            <para>
+            The logging event is passed to the <see cref="M:TraceContext.Write(string)"/> or 
+            <see cref="M:TraceContext.Warn(string)"/> method depending on the level of the logging event.
+            The event's logger name is the default value for the category parameter of the Write/Warn method. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.AspNetTraceAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.AspNetTraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the ASP.NET trace
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the ASP.NET trace
+            <c>HttpContext.Current.Trace</c> 
+            (<see cref="T:System.Web.TraceContext"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.AspNetTraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.AspNetTraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.BufferingForwardingAppender">
+            <summary>
+            Buffers events and then forwards them to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The events are buffered in this appender until conditions are
+            met to allow the appender to deliver the events to the attached 
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the
+            conditions that cause the buffer to be sent.
+            </para>
+            <para>The forwarding appender can be used to specify different 
+            thresholds and filters for the same appender at different locations 
+            within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Core.IAppenderAttachable">
+            <summary>
+            Interface for attaching appenders to objects.
+            </summary>
+            <remarks>
+            <para>
+            Interface for attaching, removing and retrieving appenders.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="appender">The appender to add.</param>
+            <remarks>
+            <para>
+            Add the specified appender. The implementation may
+            choose to allow or deny duplicate appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Returns an attached appender with the <paramref name="name"/> specified.
+            If no appender with the specified name is found <c>null</c> will be
+            returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <value>
+            A collection of attached appenders.
+            </value>
+            <remarks>
+            <para>
+            Gets a collection of attached appenders.
+            If there are no attached appenders the
+            implementation should return an empty 
+            collection rather than <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the events.
+            </summary>
+            <param name="events">The events that need to be send.</param>
+            <remarks>
+            <para>
+            Forwards the events to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this buffering appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes directly to the application's attached console
+            not to the <c>System.Console.Out</c> or <c>System.Console.Error</c> <c>TextWriter</c>.
+            The <c>System.Console.Out</c> and <c>System.Console.Error</c> streams can be
+            programmatically redirected (for example NUnit does this to capture program output).
+            This appender will ignore these redirections because it needs to use Win32
+            API calls to colorize the output. To respect these redirections the <see cref="T:log4net.Appender.ConsoleAppender"/>
+            must be used.
+            </para>
+            <para>
+            When configuring the colored console appender, mapping should be
+            specified to map a logging level to a color. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="White"/>
+            	<backColor value="Red, HighIntensity"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<backColor value="Green"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any
+            combination of the following values:
+            <list type="bullet">
+            <item><term>Blue</term><description></description></item>
+            <item><term>Green</term><description></description></item>
+            <item><term>Red</term><description></description></item>
+            <item><term>White</term><description></description></item>
+            <item><term>Yellow</term><description></description></item>
+            <item><term>Purple</term><description></description></item>
+            <item><term>Cyan</term><description></description></item>
+            <item><term>HighIntensity</term><description></description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.AddMapping(log4net.Appender.ColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_consoleOutputWriter">
+            <summary>
+            The console output stream writer to write to
+            </summary>
+            <remarks>
+            <para>
+            This writer is not thread safe.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.Colors">
+            <summary>
+            The enum of possible color values for use with the color mapping method
+            </summary>
+            <remarks>
+            <para>
+            The following flags can be combined together to
+            form the colors.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.ColoredConsoleAppender"/>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Blue">
+            <summary>
+            color is blue
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Green">
+            <summary>
+            color is green
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Red">
+            <summary>
+            color is red
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.White">
+            <summary>
+            color is white
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Yellow">
+            <summary>
+            color is yellow
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Purple">
+            <summary>
+            color is purple
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Cyan">
+            <summary>
+            color is cyan
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.HighIntensity">
+            <summary>
+            color is intensified
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ColoredConsoleAppender.LevelColors.ActivateOptions">
+            <summary>
+            Initialize the options for the object
+            </summary>
+            <remarks>
+            <para>
+            Combine the <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> together.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.CombinedColor">
+            <summary>
+            The combined <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> suitable for 
+            setting the console color.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ConsoleAppender">
+            <summary>
+            Appends logging events to the console.
+            </summary>
+            <remarks>
+            <para>
+            ConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or 
+            <c>System.Console.Error</c> that is set at the time the event is appended.
+            Therefore it is possible to programmatically redirect the output of this appender 
+            (for example NUnit does this to capture program output). While this is the desired
+            behavior of this appender it may have security implications in your application. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class
+            with the specified layout.
+            </summary>
+            <param name="layout">the layout to use for this appender</param>
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>
+            <remarks>
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to
+            the standard error output stream.  Otherwise, output is written to the standard
+            output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.DebugAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the
+            debug system.
+            </para>
+            <para>
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(string,string)"/>
+            method. The event's logger name is passed as the value for the category name to the Write method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>
+            is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.DebugAppender.m_category">
+            <summary>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.Category">
+            <summary>
+            Formats the category parameter sent to the Debug method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to a <see cref="T:log4net.Layout.PatternLayout"/> with %logger as the pattern which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender">
+            <summary>
+            Writes events to the system event log.
+            </summary>
+            <remarks>
+            <para>
+            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.
+            See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog
+            </para>
+            <para>
+            The <c>EventID</c> of the event log entry can be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            The <c>Category</c> of the event log entry can be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            <para>
+            When configuring the EventLogAppender a mapping can be
+            specified to map a logging level to an event log entry type. For example:
+            </para>
+            <code lang="XML">
+            &lt;mapping&gt;
+            	&lt;level value="ERROR" /&gt;
+            	&lt;eventLogEntryType value="Error" /&gt;
+            &lt;/mapping&gt;
+            &lt;mapping&gt;
+            	&lt;level value="DEBUG" /&gt;
+            	&lt;eventLogEntryType value="Information" /&gt;
+            &lt;/mapping&gt;
+            </code>
+            <para>
+            The Level is the standard log4net logging level and eventLogEntryType can be any value
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:
+            <list type="bullet">
+            <item><term>Error</term><description>an error event</description></item>
+            <item><term>Warning</term><description>a warning event</description></item>
+            <item><term>Information</term><description>an informational event</description></item>
+            </list>
+            </para>
+            </remarks>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Thomas Voss</author>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.
+            </summary>
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">
+            <summary>
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.
+            Each mapping defines the event log entry type for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">
+            <summary>
+            Create an event log source
+            </summary>
+            <remarks>
+            Uses different API calls under NET_2_0
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Writes the event to the system event log using the 
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>
+            
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            set then this integer will be used as the event log event id.</para>
+            
+            <para>
+            There is a limit of 32K characters for an event log message
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">
+            <summary>
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/>
+            </summary>
+            <param name="level">the Level to convert to an EventLogEntryType</param>
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/></returns>
+            <remarks>
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
+            values to use in logging levels than there are in the 
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is
+            a loss of information during the conversion.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">
+            <summary>
+            The log name is the section in the event logs where the messages
+            are stored.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
+            <summary>
+            Name of the application to use when logging.  This appears in the
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
+            <summary>
+            The name of the machine which holds the event log. This is
+            currently only allowed to be '.' i.e. the current machine.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to EventLogEntryType
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_eventId">
+            <summary>
+            The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.m_category">
+            <summary>
+            The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.declaringType">
+            <summary>
+            The fully qualified type of the EventLogAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_DEFAULT">
+            <summary>
+            The maximum size supported by default.
+            </summary>
+            <remarks>
+            http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx
+            The 32766 documented max size is two bytes shy of 32K (I'm assuming 32766 
+            may leave space for a two byte null terminator of #0#0). The 32766 max 
+            length is what the .NET 4.0 source code checks for, but this is WRONG! 
+            Strings with a length > 31839 on Windows Vista or higher can CORRUPT 
+            the event log! See: System.Diagnostics.EventLogInternal.InternalWriteEvent() 
+            for the use of the 32766 max size.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_VISTA_OR_NEWER">
+            <summary>
+            The maximum size supported by a windows operating system that is vista
+            or newer.
+            </summary>
+            <remarks>
+            See ReportEvent API:
+            	http://msdn.microsoft.com/en-us/library/aa363679(VS.85).aspx
+            ReportEvent's lpStrings parameter:
+            "A pointer to a buffer containing an array of 
+            null-terminated strings that are merged into the message before Event Viewer 
+            displays the string to the user. This parameter must be a valid pointer 
+            (or NULL), even if wNumStrings is zero. Each string is limited to 31,839 characters."
+            
+            Going beyond the size of 31839 will (at some point) corrupt the event log on Windows
+            Vista or higher! It may succeed for a while...but you will eventually run into the
+            error: "System.ComponentModel.Win32Exception : A device attached to the system is
+            not functioning", and the event log will then be corrupt (I was able to corrupt 
+            an event log using a length of 31877 on Windows 7).
+            
+            The max size for Windows Vista or higher is documented here:
+            	http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx.
+            Going over this size may succeed a few times but the buffer will overrun and 
+            eventually corrupt the log (based on testing).
+            
+            The maxEventMsgSize size is based on the max buffer size of the lpStrings parameter of the ReportEvent API.
+            The documented max size for EventLog.WriteEntry for Windows Vista and higher is 31839, but I'm leaving room for a
+            terminator of #0#0, as we cannot see the source of ReportEvent (though we could use an API monitor to examine the
+            buffer, given enough time).
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE">
+            <summary>
+            The maximum size that the operating system supports for
+            a event log message.
+            </summary>
+            <remarks>
+            Used to determine the maximum string length that can be written
+            to the operating system event log and eventually truncate a string
+            that exceeds the limits.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.EventLogAppender.GetMaxEventLogMessageSize">
+            <summary>
+            This method determines the maximum event log message size allowed for
+            the current environment.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.LogName">
+            <summary>
+            The name of the log where messages will be stored.
+            </summary>
+            <value>
+            The string name of the log where messages will be stored.
+            </value>
+            <remarks>
+            <para>This is the name of the log as it appears in the Event Viewer
+            tree. The default value is to log into the <c>Application</c>
+            log, this is where most applications write their events. However
+            if you need a separate log for your application (or applications)
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
+            <para>This should not be used to distinguish your event log messages
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
+            property should be used to distinguish events. This property should be 
+            used to group together events into a single log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
+            <summary>
+            Property used to set the Application name.  This appears in the
+            event logs when logging.
+            </summary>
+            <value>
+            The string used to distinguish events from different sources.
+            </value>
+            <remarks>
+            Sets the event log source property.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">
+            <summary>
+            This property is used to return the name of the computer to use
+            when accessing the event logs.  Currently, this is the current
+            computer, denoted by a dot "."
+            </summary>
+            <value>
+            The string name of the machine holding the event log that 
+            will be logged into.
+            </value>
+            <remarks>
+            This property cannot be changed. It is currently set to '.'
+            i.e. the local machine. This may be changed in future.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.
+            </value>
+            <remarks>
+            <para>
+            The system security context used to write to the EventLog.
+            </para>
+            <para>
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.EventId">
+            <summary>
+            Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>EventID</c> of the event log entry will normally be
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Category">
+            <summary>
+            Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Category</c> of the event log entry will normally be
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.
+            This property provides the fallback value which defaults to 0.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and its event log entry type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">
+            <summary>
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender">
+            <summary>
+            Appends logging events to a file.
+            </summary>
+            <remarks>
+            <para>
+            Logging events are sent to the file specified by
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.
+            </para>
+            <para>
+            The file can be opened in either append or overwrite mode 
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.
+            If the file path is relative it is taken as relative from 
+            the application base directory. The file encoding can be
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.
+            </para>
+            <para>
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            values will be written each time the file is opened and closed
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>
+            then the file may contain multiple copies of the header and footer.
+            </para>
+            <para>
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> 
+            is to obtain an exclusive write lock on the file until this appender is closed.
+            The alternative models only hold a
+            write lock while the appender is writing a logging event (<see cref="T:log4net.Appender.FileAppender.MinimalLock"/>)
+            or synchronize by using a named system wide Mutex (<see cref="T:log4net.Appender.FileAppender.InterProcessLock"/>).
+            </para>
+            <para>
+            All locking strategies have issues and you should seriously consider using a different strategy that
+            avoids having multiple processes logging to the same file.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Rodrigo B. de Oliveira</author>
+            <author>Douglas de la Torre</author>
+            <author>Niall Daley</author>
+        </member>
+        <member name="T:log4net.Appender.TextWriterAppender">
+            <summary>
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This appender may be used stand alone if initialized with an appropriate
+            writer, however it is typically used as a base class for an appender that
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized 
+            with the specified <see cref="T:System.IO.Stream"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
+            </summary>
+            <param name="layout">The layout to use with this appender</param>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
+            <remarks>
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
+            <summary>
+            This method determines if there is a sense in attempting to append.
+            </summary>
+            <remarks>
+            <para>
+            This method checks if an output target has been set and if a
+            layout has been set. 
+            </para>
+            </remarks>
+            <returns><c>false</c> if any of the preconditions fail.</returns>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            This method writes all the bulk logged events to the output writer
+            before flushing the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+            <remarks>
+            Closed appenders cannot be reused.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
+            <summary>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">
+            <summary>
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> 
+            and other variables.
+            </summary>
+            <remarks>
+            <para>
+            Subclasses can override this method for an alternate closing behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
+            <summary>
+            Called to allow a subclass to lazily initialize the writer
+            </summary>
+            <remarks>
+            <para>
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
+            attempt to initialize the writer multiple times.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
+            <summary>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> 
+            or output stream will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logging events are not actually persisted if and when the application 
+            crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TextWriterAppender.declaringType">
+            <summary>
+            The fully qualified type of the TextWriterAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TextWriterAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
+            <summary>
+            Gets or set whether the appender will flush at the end 
+            of each append operation.
+            </summary>
+            <value>
+            <para>
+            The default behavior is to flush at the end of each 
+            append operation.
+            </para>
+            <para>
+            If this option is set to <c>false</c>, then the underlying 
+            stream can defer persisting the logging event to a later 
+            time.
+            </para>
+            </value>
+            <remarks>
+            Avoiding the flush operation at the end of each append results in
+            a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">
+            <summary>
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
+            </summary>
+            <remarks>
+            <para>
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
+            </para>
+            <para>
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender 
+            instance is closed.
+            </para>
+            <para>
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
+            <summary>
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying 
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
+            </value>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </summary>
+            <value>
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
+            </value>
+            <remarks>
+            <para>
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
+            will be written to. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
+            <summary>
+            Construct a new appender using the layout, file and append mode.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <param name="append">flag to indicate if the file should be appended to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
+            <summary>
+            Construct a new appender using the layout and file specified.
+            The file will be appended to.
+            </summary>
+            <param name="layout">the layout to use with this appender</param>
+            <param name="filename">the full path to the file to write to</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
+            <summary>
+            Activate the options on the file appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This will cause the file to be opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Reset">
+            <summary>
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.
+            </summary>
+            <remarks>
+            <para>
+            Resets the filename and the file stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OnClose">
+            <summary>
+            Close this appender instance. The underlying stream or writer is also closed.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">
+            <summary>
+            Called to initialize the file writer
+            </summary>
+            <remarks>
+            <para>
+            Will be called for each logged message until the file is
+            successfully opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>
+            method. 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes a log statement to the output stream if the output stream exists 
+            and is writable.  
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>
+            method. 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Acquires the output file locks once before writing all the events to
+            the stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">
+            <summary>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">
+            <summary>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </summary>
+            <remarks>
+            <para>
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">
+            <summary>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.CloseFile">
+            <summary>
+            Closes the previously opened file.
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then
+            closes the file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.
+            </summary>
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
+            <remarks>
+            <para>
+            If there was already an opened file, then the previous file
+            is closed first.
+            </para>
+            <para>
+            This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">
+            <summary>
+            Sets the quiet writer used for file output
+            </summary>
+            <param name="fileStream">the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This implementation of <see cref="M:SetQWForFiles(Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>
+            over the <paramref name="fileStream"/> and passes it to the 
+            <see cref="M:SetQWForFiles(TextWriter)"/> method.
+            </para>
+            <para>
+            This method can be overridden by sub classes that want to wrap the
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <param name="writer">the writer over the file stream that has been opened for writing</param>
+            <remarks>
+            <para>
+            This method can be overridden by sub classes that want to
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
+            <summary>
+            Flag to indicate if we should append to the file
+            or overwrite the file. The default is to append.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_fileName">
+            <summary>
+            The name of the log file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_encoding">
+            <summary>
+            The encoding to use for the file stream.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_stream">
+            <summary>
+            The stream to log to. Has added locking semantics
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">
+            <summary>
+            The locking model to use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.FileAppender.declaringType">
+            <summary>
+            The fully qualified type of the FileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.File">
+            <summary>
+            Gets or sets the path to the file that logging will be written to.
+            </summary>
+            <value>
+            The path to the file that logging will be written to.
+            </value>
+            <remarks>
+            <para>
+            If the path is relative it is taken as relative from 
+            the application base directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">
+            <summary>
+            Gets or sets a flag that indicates whether the file should be
+            appended to or overwritten.
+            </summary>
+            <value>
+            Indicates whether the file should be appended to or overwritten.
+            </value>
+            <remarks>
+            <para>
+            If the value is set to false then the file will be overwritten, if 
+            it is set to true then the file will be appended to.
+            </para>
+            The default value is true.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>
+            which is the encoding for the system's current ANSI code page.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModel">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.
+            </para>
+            <para>
+            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"/> .
+            The first locks the file from the start of logging to the end, the 
+            second locks only for the minimal amount of time when logging each message
+            and the last synchronizes processes using a named system wide Mutex.
+            </para>
+            <para>
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingStream">
+            <summary>
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> 
+            to manage access to an underlying resource.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
+            <summary>
+            True asynchronous writes are not supported, the implementation forces a synchronous write.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LogException">
+            <summary>
+            Exception base type for log4net.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with
+            the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">
+            <summary>
+            Locking model base class
+            </summary>
+            <remarks>
+            <para>
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the output file
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CreateStream(System.String,System.Boolean,System.IO.FileShare)">
+            <summary>
+            Helper method that creates a FileStream under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            <para>
+            Typically called during OpenFile or AcquireLock. 
+            </para>
+            <para>
+            If the directory portion of the <paramref name="filename"/> does not exist, it is created
+            via Directory.CreateDirecctory.
+            </para>
+            </remarks>
+            <param name="filename"></param>
+            <param name="append"></param>
+            <param name="fileShare"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseStream(System.IO.Stream)">
+            <summary>
+            Helper method to close <paramref name="stream"/> under CurrentAppender's SecurityContext.
+            </summary>
+            <remarks>
+            Does not set <paramref name="stream"/> to null.
+            </remarks>
+            <param name="stream"></param>
+        </member>
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </summary>
+            <value>
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel
+            </value>
+            <remarks>
+            <para>
+            The file appender this locking model is attached to and working on
+            behalf of.
+            </para>
+            <para>
+            The file appender is used to locate the security context and the error handler to use.
+            </para>
+            <para>
+            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
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">
+            <summary>
+            Hold an exclusive lock on the output file
+            </summary>
+            <remarks>
+            <para>
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. 
+            Maintains an exclusive lock on the file during this time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Does nothing. The lock will be released when the file is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">
+            <summary>
+            Acquires the file lock for each write
+            </summary>
+            <remarks>
+            <para>
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, 
+            thus holding the lock for the minimal amount of time. This method of locking
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows 
+            other processes to move/delete the log file whilst logging continues.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Prepares to open the file when the first message is logged.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Acquire the lock on the file in preparation for writing to it. 
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>
+            must be called to release the lock on the output file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">
+            <summary>
+            Release the lock on the file
+            </summary>
+            <remarks>
+            <para>
+            Release the lock on the file. No further writes will be made to the 
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.FileAppender.InterProcessLock">
+            <summary>
+            Provides cross-process file locking.
+            </summary>
+            <author>Ron Grabowski</author>
+            <author>Steve Wranovsky</author>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">
+            <summary>
+            Open the file specified and prepare for logging.
+            </summary>
+            <param name="filename">The filename to use</param>
+            <param name="append">Whether to append to the file, or overwrite</param>
+            <param name="encoding">The encoding to use</param>
+            <remarks>
+            <para>
+            Open the file specified and prepare for logging. 
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/> is called.
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/>,
+            -<see cref="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile">
+            <summary>
+            Close the file
+            </summary>
+            <remarks>
+            <para>
+            Close the file. No further writes will be made.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock">
+            <summary>
+            Acquire the lock on the file
+            </summary>
+            <returns>A stream that is ready to be written to.</returns>
+            <remarks>
+            <para>
+            Does nothing. The lock is already taken
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock">
+            <summary>
+            Releases the lock and allows others to acquire a lock.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ActivateOptions">
+            <summary>
+            Initializes all resources used by this locking model.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OnClose">
+            <summary>
+            Disposes all resources that were initialized by this locking model.
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.ForwardingAppender">
+            <summary>
+            This appender forwards logging events to attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            The forwarding appender can be used to specify different thresholds
+            and filters for the same appender at different locations within the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">
+            <summary>
+            Closes the appender and releases resources.
+            </summary>
+            <remarks>
+            <para>
+            Releases any resources allocated within the appender such as file handles, 
+            network connections, etc.
+            </para>
+            <para>
+            It is a programming error to append to a closed appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Forward the logging event to the attached appenders 
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Forward the logging events to the attached appenders 
+            </summary>
+            <param name="loggingEvents">The array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers the logging events to all the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
+            instance.
+            </summary>
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
+            <remarks>
+            <para>
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
+            <summary>
+            Looks for the appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to lookup.</param>
+            <returns>
+            The appender with the specified name, or <c>null</c>.
+            </returns>
+            <remarks>
+            <para>
+            Get the named appender attached to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
+            <summary>
+            Removes all previously added appenders from this appender.
+            </summary>
+            <remarks>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">
+            <summary>
+            Gets the appenders contained in this appender as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> 
+            is returned.
+            </remarks>
+            <returns>
+            A collection of the appenders in this appender.
+            </returns>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender">
+            <summary>
+            Logs events to a local syslog service.
+            </summary>
+            <remarks>
+            <note>
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.
+            If these functions are not available on the local system then this appender will not work!
+            </note>
+            <para>
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and 
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.
+            </para>
+            <para>
+            This appender talks to a local syslog service. If you need to log to a remote syslog
+            daemon and you cannot configure your local syslog service to do this you may be
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write 
+            to a local syslog service.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">
+            <summary>
+            Close the syslog when the appender is closed
+            </summary>
+            <remarks>
+            <para>
+            Close the syslog when the appender is closed
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">
+            <summary>
+            Marshaled handle to the identity string. We have to hold on to the
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the
+            pointer to the ident and dereference it for each log message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">
+            <summary>
+            Open connection to system logger.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">
+            <summary>
+            Generate a log message.
+            </summary>
+            <remarks>
+            <para>
+            The libc syslog method takes a format string and a variable argument list similar
+            to the classic printf function. As this type of vararg list is not supported
+            by C# we need to specify the arguments explicitly. Here we have specified the
+            format string with a single message argument. The caller must set the format 
+            string to <c>"%s"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">
+            <summary>
+            Close descriptor used to write to system logger.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The log4net Level maps to a syslog severity using the
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facility defines which subsystem the logging comes from.
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender">
+            <summary>
+            Appends colorful logging events to the console, using the .NET 2
+            built-in capabilities.
+            </summary>
+            <remarks>
+            <para>
+            ManagedColoredConsoleAppender appends log events to the standard output stream
+            or the error output stream using a layout specified by the 
+            user. It also allows the color of a specific type of message to be set.
+            </para>
+            <para>
+            By default, all output is written to the console's standard output stream.
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> property can be set to direct the output to the
+            error stream.
+            </para>
+            <para>
+            When configuring the colored console appender, mappings should be
+            specified to map logging levels to colors. For example:
+            </para>
+            <code lang="XML" escaped="true">
+            <mapping>
+            	<level value="ERROR"/>
+            	<foreColor value="DarkRed"/>
+            	<backColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="WARN"/>
+            	<foreColor value="Yellow"/>
+            </mapping>
+            <mapping>
+            	<level value="INFO"/>
+            	<foreColor value="White"/>
+            </mapping>
+            <mapping>
+            	<level value="DEBUG"/>
+            	<foreColor value="Blue"/>
+            </mapping>
+            </code>
+            <para>
+            The Level is the standard log4net logging level while
+            ForeColor and BackColor are the values of <see cref="T:System.ConsoleColor"/>
+            enumeration.
+            </para>
+            <para>
+            Based on the ColoredConsoleAppender
+            </para>
+            </remarks>
+            <author>Rick Hobbs</author>
+            <author>Nicko Cadell</author>
+            <author>Pavlos Touboulidis</author>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleOut">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleError">
+            <summary>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console 
+            standard error output stream.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class.
+            </summary>
+            <remarks>
+            The instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class is set up to write 
+            to the standard output stream.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.AddMapping(log4net.Appender.ManagedColoredConsoleAppender.LevelColors)">
+            <summary>
+            Add a mapping of level to color - done by the config file
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors"/> mapping to this appender.
+            Each mapping defines the foreground and background colors
+            for a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to the console.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to color mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_writeToErrorStream">
+            <summary>
+            Flag to write output to the error stream rather than the standard output stream
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to color value
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.Target">
+            <summary>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </summary>
+            <value>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </value>
+            <remarks>
+            <para>
+            Target is the value of the console output stream.
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the color it should be displayed as.
+            </summary>
+            <remarks>
+            <para>
+            Defines the mapping between a level and the color it should be displayed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.ForeColor">
+            <summary>
+            The mapped foreground color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped foreground color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.BackColor">
+            <summary>
+            The mapped background color for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped background color for the specified level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.MemoryAppender">
+            <summary>
+            Stores logging events in an array.
+            </summary>
+            <remarks>
+            <para>
+            The memory appender stores all the logging events
+            that are appended in an in-memory array.
+            </para>
+            <para>
+            Use the <see cref="M:PopAllEvents()"/> method to get
+            and clear the current list of events that have been appended.
+            </para>
+            <para>
+            Use the <see cref="M:GetEvents()"/> method to get the current
+            list of events that have been appended.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            <para>
+            Use the <see cref="M:Clear()"/> method to clear the
+            current list of events.  Note there is a
+            race-condition when calling <see cref="M:GetEvents()"/> and
+            <see cref="M:Clear()"/> in pairs, you better use <see
+            mref="M:PopAllEvents()"/> in that case.
+            </para>
+            </remarks>
+            <author>Julian Biddle</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">
+            <summary>
+            Gets the events that have been logged.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. 
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.Clear">
+            <summary>
+            Clear the list of events
+            </summary>
+            <remarks>
+            Clear the list of events
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.MemoryAppender.PopAllEvents">
+            <summary>
+            Gets the events that have been logged and clears the list of events.
+            </summary>
+            <returns>The events that have been logged</returns>
+            <remarks>
+            <para>
+            Gets the events that have been logged and clears the list of events.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
+            <summary>
+            The list of events that have been appended.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
+            <summary>
+            Value indicating which fields in the event should be fixed
+            </summary>
+            <remarks>
+            By default all fields are fixed
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
+            <summary>
+            Gets or sets a value indicating whether only part of the logging event 
+            data should be fixed.
+            </summary>
+            <value>
+            <c>true</c> if the appender should only fix part of the logging event 
+            data, otherwise <c>false</c>. The default is <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Setting this property to <c>true</c> will cause only part of the event 
+            data to be fixed and stored in the appender, hereby improving performance. 
+            </para>
+            <para>
+            See <see cref="M:LoggingEvent.FixVolatileData(bool)"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.MemoryAppender.Fix">
+            <summary>
+            Gets or sets the fields that will be fixed in the event
+            </summary>
+            <remarks>
+            <para>
+            The logging event needs to have certain thread specific values 
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
+            for details.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.NetSendAppender">
+            <summary>
+            Logs entries by sending network messages using the 
+            <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> native function.
+            </summary>
+            <remarks>
+            <para>
+            You can send messages only to names that are active 
+            on the network. If you send the message to a user name, 
+            that user must be logged on and running the Messenger 
+            service to receive the message.
+            </para>
+            <para>
+            The receiver will get a top most window displaying the 
+            messages one at a time, therefore this appender should 
+            not be used to deliver a high volume of messages.
+            </para>
+            <para>
+            The following table lists some possible uses for this appender :
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Action</term>
+                    <description>Property Value(s)</description>
+                </listheader>
+                <item>
+                    <term>Send a message to a user account on the local machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a user account on a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the remote machine&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to a domain user account</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of a domain controller | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message to all the names in a workgroup or domain</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;workgroup name | domain name&gt;*
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Send a message from the local machine to a remote machine</term>
+                    <description>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine | uninitialized&gt;
+                        </para>
+                        <para>
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;name of the remote machine&gt;
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            <b>Note :</b> security restrictions apply for sending 
+            network messages, see <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> 
+            for more information.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            An example configuration section to log information 
+            using this appender from the local machine, named 
+            LOCAL_PC, to machine OPERATOR_PC :
+            </para>
+            <code lang="XML" escaped="true">
+            <appender name="NetSendAppender_Operator" type="log4net.Appender.NetSendAppender">
+                <server value="LOCAL_PC"/>
+                <recipient value="OPERATOR_PC"/>
+                <layout type="log4net.Layout.PatternLayout" value="%-5p %c [%x] - %m%n"/>
+            </appender>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_server">
+            <summary>
+            The DNS or NetBIOS name of the server on which the function is to execute.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_sender">
+            <summary>
+            The sender of the network message.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_recipient">
+            <summary>
+            The message alias to which the message should be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.NetSendAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.#ctor">
+            <summary>
+            Initializes the appender.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was not specified.</exception>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using a network message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)">
+            <summary>
+            Sends a buffer of information to a registered message alias.
+            </summary>
+            <param name="serverName">The DNS or NetBIOS name of the server on which the function is to execute.</param>
+            <param name="msgName">The message alias to which the message buffer should be sent</param>
+            <param name="fromName">The originator of the message.</param>
+            <param name="buffer">The message text.</param>
+            <param name="bufferSize">The length, in bytes, of the message text.</param>
+            <remarks>
+            <para>
+            The following restrictions apply for sending network messages:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>Platform</term>
+                    <description>Requirements</description>
+                </listheader>
+                <item>
+                    <term>Windows NT</term>
+                    <description>
+                        <para>
+                        No special group membership is required to send a network message.
+                        </para>
+                        <para>
+                        Admin, Accounts, Print, or Server Operator group membership is required to 
+                        successfully send a network message on a remote server.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>Windows 2000 or later</term>
+                    <description>
+                        <para>
+                        If you send a message on a domain controller that is running Active Directory, 
+                        access is allowed or denied based on the access control list (ACL) for the securable 
+                        object. The default ACL permits only Domain Admins and Account Operators to send a network message. 
+                        </para>
+                        <para>
+                        On a member server or workstation, only Administrators and Server Operators can send a network message. 
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            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>.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is zero.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Sender">
+            <summary>
+            Gets or sets the sender of the message.
+            </summary>
+            <value>
+            The sender of the message.
+            </value>
+            <remarks>
+            If this property is not specified, the message is sent from the local computer.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Recipient">
+            <summary>
+            Gets or sets the message alias to which the message should be sent.
+            </summary>
+            <value>
+            The recipient of the message.
+            </value>
+            <remarks>
+            This property should always be specified in order to send a message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.Server">
+            <summary>
+            Gets or sets the DNS or NetBIOS name of the remote server on which the function is to execute.
+            </summary>
+            <value>
+            DNS or NetBIOS name of the remote server on which the function is to execute.
+            </value>
+            <remarks>
+            <para>
+            For Windows NT 4.0 and earlier, the string should begin with \\.
+            </para>
+            <para>
+            If this property is not specified, the local computer is used. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.NetSendAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.OutputDebugStringAppender">
+            <summary>
+            Appends log events to the OutputDebugString system.
+            </summary>
+            <remarks>
+            <para>
+            OutputDebugStringAppender appends log events to the
+            OutputDebugString system.
+            </para>
+            <para>
+            The string is passed to the native <c>OutputDebugString</c> 
+            function.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.OutputDebugStringAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write the logging event to the output debug string API
+            </summary>
+            <param name="loggingEvent">the event to log</param>
+            <remarks>
+            <para>
+            Write the logging event to the output debug string API
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">
+            <summary>
+            Stub for OutputDebugString native method
+            </summary>
+            <param name="message">the string to output</param>
+            <remarks>
+            <para>
+            Stub for OutputDebugString native method
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.OutputDebugStringAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender">
+            <summary>
+            Logs events to a remote syslog daemon.
+            </summary>
+            <remarks>
+            <para>
+            The BSD syslog protocol is used to remotely log to
+            a syslog daemon. The syslogd listens for for messages
+            on UDP port 514.
+            </para>
+            <para>
+            The syslog UDP protocol is not authenticated. Most syslog daemons
+            do not accept remote log messages because of the security implications.
+            You may be able to use the LocalSyslogAppender to talk to a local
+            syslog service.
+            </para>
+            <para>
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.
+            This appender generates what the RFC calls an "Original Device Message",
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation
+            this format of message will be accepted by all current syslog daemon
+            implementations. The daemon will attach the current time and the source
+            hostname or IP address to any messages received.
+            </para>
+            <para>
+            Syslog messages must have a facility and and a severity. The severity
+            is derived from the Level of the logging event.
+            The facility must be chosen from the set of defined syslog 
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined
+            and cannot be extended.
+            </para>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+            <author>Rob Lyon</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Appender.UdpAppender">
+             <summary>
+             Sends logging events as connectionless UDP datagrams to a remote host or a 
+             multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.
+             </summary>
+             <remarks>
+             <para>
+             UDP guarantees neither that messages arrive, nor that they arrive in the correct order.
+             </para>
+             <para>
+             To view the logging results, a custom application can be developed that listens for logging 
+             events.
+             </para>
+             <para>
+             When decoding events send via this appender remember to use the same encoding
+             to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>
+             property to specify the encoding to use.
+             </para>
+             </remarks>
+             <example>
+             This example shows how to log receive logging events that are sent 
+             on IP address 244.0.0.1 and port 8080 to the console. The event is 
+             encoded in the packet as a unicode string and it is decoded as such. 
+             <code lang="C#">
+             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+             UdpClient udpClient;
+             byte[] buffer;
+             string loggingEvent;
+             
+             try 
+             {
+                 udpClient = new UdpClient(8080);
+                 
+                 while(true) 
+                 {
+                     buffer = udpClient.Receive(ref remoteEndPoint);
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
+                     Console.WriteLine(loggingEvent);
+                 }
+             } 
+             catch(Exception e) 
+             {
+                 Console.WriteLine(e.ToString());
+             }
+             </code>
+             <code lang="Visual Basic">
+             Dim remoteEndPoint as IPEndPoint
+             Dim udpClient as UdpClient
+             Dim buffer as Byte()
+             Dim loggingEvent as String
+             
+             Try 
+                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
+                 udpClient = new UdpClient(8080)
+            
+                 While True
+                     buffer = udpClient.Receive(ByRef remoteEndPoint)
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
+                     Console.WriteLine(loggingEvent)
+                 Wend
+             Catch e As Exception
+                 Console.WriteLine(e.ToString())
+             End Try
+             </code>
+             <para>
+             An example configuration section to log information using this appender to the 
+             IP 224.0.0.1 on port 8080:
+             </para>
+             <code lang="XML" escaped="true">
+             <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
+                 <remoteAddress value="224.0.0.1"/>
+                 <remotePort value="8080"/>
+                 <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>
+             </appender>
+             </code>
+             </example>
+             <author>Gert Driesen</author>
+             <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.
+            </summary>
+            <remarks>
+            The default constructor initializes all fields to their default values.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or 
+            an invalid remote or local TCP port number was specified.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>
+            <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>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Sends the event using an UDP datagram.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.OnClose">
+            <summary>
+            Closes the UDP connection and releases all resources associated with 
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed 
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">
+            <summary>
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.
+            </summary>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the 
+            port number from which you intend to communicate.
+            </para>
+            <para>
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">
+            <summary>
+            The IP address of the remote host or multicast group to which 
+            the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">
+            <summary>
+            The TCP port number of the remote host or multicast group to 
+            which the logging event will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">
+            <summary>
+            The cached remote endpoint to which the logging events will be sent.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">
+            <summary>
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_client">
+            <summary>
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the 
+            logging events.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">
+            <summary>
+            The encoding to use for the packet.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">
+            <summary>
+            Gets or sets the IP address of the remote host or multicast group to which
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            The IP address of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            <para>
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so
+            it is possible to use multicasts in an Internet scenario as long as your network provider 
+            supports multicasting.
+            </para>
+            <para>
+            Hosts that want to receive particular multicast messages must register their interest by joining
+            the multicast group.  Multicast messages are not sent to networks where no host has joined
+            the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate
+            them from normal host addresses, allowing nodes to easily detect if a message is of interest.
+            </para>
+            <para>
+            Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:
+            </para>
+            <para>
+            <list type="table">
+                <listheader>
+                    <term>IP Address</term>
+                    <description>Description</description>
+                </listheader>
+                <item>
+                    <term>224.0.0.1</term>
+                    <description>
+                        <para>
+                        Sends a message to all system on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.2</term>
+                    <description>
+                        <para>
+                        Sends a message to all routers on the subnet.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>224.0.0.12</term>
+                    <description>
+                        <para>
+                        The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.
+                        </para>
+                    </description>
+                </item>
+            </list>
+            </para>
+            <para>
+            A complete list of actually reserved multicast addresses and their owners in the ranges
+            defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. 
+            </para>
+            <para>
+            The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative 
+            addresses.  These addresses can be reused with other local groups.  Routers are typically 
+            configured with filters to prevent multicast traffic in this range from flowing outside
+            of the local network.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemotePort">
+            <summary>
+            Gets or sets the TCP port number of the remote host or multicast group to which 
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number of the remote host or multicast group to which the logging event 
+            will be sent.
+            </value>
+            <remarks>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will send messages to this TCP port number
+            on the remote host or multicast group.
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.LocalPort">
+            <summary>
+            Gets or sets the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.
+            </value>
+            <remarks>
+            <para>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will bind to this port for sending messages.
+            </para>
+            <para>
+            Setting the value to 0 (the default) will cause the udp client not to bind to
+            a local port.
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Encoding">
+            <summary>
+            Gets or sets <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.Client">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/>.
+            </value>
+            <remarks>
+            <see cref="T:log4net.Appender.UdpAppender"/> creates a <see cref="T:System.Net.Sockets.UdpClient"/> to send logging events 
+            over a network.  Classes deriving from <see cref="T:log4net.Appender.UdpAppender"/> can use this
+            property to get or set this <see cref="T:System.Net.Sockets.UdpClient"/>.  Use the underlying <see cref="T:System.Net.Sockets.UdpClient"/>
+            returned from <see cref="P:log4net.Appender.UdpAppender.Client"/> if you require access beyond that which 
+            <see cref="T:log4net.Appender.UdpAppender"/> provides.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RemoteEndPoint">
+            <summary>
+            Gets or sets the cached remote endpoint to which the logging events should be sent.
+            </summary>
+            <value>
+            The cached remote endpoint to which the logging events will be sent.
+            </value>
+            <remarks>
+            The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method will initialize the remote endpoint 
+            with the values of the <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> and <see cref="P:log4net.Appender.UdpAppender.RemotePort"/>
+            properties.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.UdpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.DefaultSyslogPort">
+            <summary>
+            Syslog port 514
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class.
+            </summary>
+            <remarks>
+            This instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class is set up to write 
+            to a remote syslog daemon.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.AddMapping(log4net.Appender.RemoteSyslogAppender.LevelSeverity)">
+            <summary>
+            Add a mapping of level to severity
+            </summary>
+            <param name="mapping">The mapping to add</param>
+            <remarks>
+            <para>
+            Add a <see cref="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity"/> mapping to this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the event to a remote syslog daemon.
+            </para>
+            <para>
+            The format of the output will depend on the appender's layout.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.ActivateOptions">
+            <summary>
+            Initialize the options for this appender
+            </summary>
+            <remarks>
+            <para>
+            Initialize the level to syslog severity mappings set on this appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GetSeverity(log4net.Core.Level)">
+            <summary>
+            Translates a log4net level to a syslog severity.
+            </summary>
+            <param name="level">A log4net level.</param>
+            <returns>A syslog severity.</returns>
+            <remarks>
+            <para>
+            Translates a log4net level to a syslog severity.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GeneratePriority(log4net.Appender.RemoteSyslogAppender.SyslogFacility,log4net.Appender.RemoteSyslogAppender.SyslogSeverity)">
+            <summary>
+            Generate a syslog priority.
+            </summary>
+            <param name="facility">The syslog facility.</param>
+            <param name="severity">The syslog severity.</param>
+            <returns>A syslog priority.</returns>
+            <remarks>
+            <para>
+            Generate a syslog priority.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_facility">
+            <summary>
+            The facility. The default facility is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_identity">
+            <summary>
+            The message identity
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_levelMapping">
+            <summary>
+            Mapping from level object to syslog severity
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Identity">
+            <summary>
+            Message identity
+            </summary>
+            <remarks>
+            <para>
+            An identifier is specified with each log message. This can be specified
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know 
+            as the tag) must not contain white space. The default value for the
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Facility">
+            <summary>
+            Syslog facility
+            </summary>
+            <remarks>
+            Set to one of the <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The list of
+            facilities is predefined and cannot be extended. The default value
+            is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogSeverity">
+            <summary>
+            syslog severities
+            </summary>
+            <remarks>
+            <para>
+            The syslog severities.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Emergency">
+            <summary>
+            system is unusable
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Alert">
+            <summary>
+            action must be taken immediately
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Critical">
+            <summary>
+            critical conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Error">
+            <summary>
+            error conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Warning">
+            <summary>
+            warning conditions
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Notice">
+            <summary>
+            normal but significant condition
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Informational">
+            <summary>
+            informational
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Debug">
+            <summary>
+            debug-level messages
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility">
+            <summary>
+            syslog facilities
+            </summary>
+            <remarks>
+            <para>
+            The syslog facilities
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Kernel">
+            <summary>
+            kernel messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User">
+            <summary>
+            random user-level messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Mail">
+            <summary>
+            mail system
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Daemons">
+            <summary>
+            system daemons
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization">
+            <summary>
+            security/authorization messages
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Syslog">
+            <summary>
+            messages generated internally by syslogd
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Printer">
+            <summary>
+            line printer subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.News">
+            <summary>
+            network news subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Uucp">
+            <summary>
+            UUCP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock">
+            <summary>
+            clock (cron/at) daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization2">
+            <summary>
+            security/authorization  messages (private)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ftp">
+            <summary>
+            ftp daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ntp">
+            <summary>
+            NTP subsystem
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Audit">
+            <summary>
+            log audit
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Alert">
+            <summary>
+            log alert
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock2">
+            <summary>
+            clock daemon
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local0">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local1">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local2">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local3">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local4">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local5">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local6">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local7">
+            <summary>
+            reserved for local use
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity">
+            <summary>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </summary>
+            <remarks>
+            <para>
+            A class to act as a mapping between the level that a logging call is made at and
+            the syslog severity that is should be logged at.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemoteSyslogAppender.LevelSeverity.Severity">
+            <summary>
+            The mapped syslog severity for the specified level
+            </summary>
+            <remarks>
+            <para>
+            Required property.
+            The mapped syslog severity for the specified level
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender">
+            <summary>
+            Delivers logging events to a remote logging sink. 
+            </summary>
+            <remarks>
+            <para>
+            This Appender is designed to deliver events to a remote sink. 
+            That is any object that implements the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface. It delivers the events using .NET remoting. The
+            object to deliver events to is specified by setting the
+            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.</para>
+            <para>
+            The RemotingAppender buffers events before sending them. This allows it to 
+            make more efficient use of the remoting infrastructure.</para>
+            <para>
+            Once the buffer is full the events are still not sent immediately. 
+            They are scheduled to be sent using a pool thread. The effect is that 
+            the send occurs asynchronously. This is very important for a 
+            number of non obvious reasons. The remoting infrastructure will 
+            flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.</para>
+            <para>
+            Because the events are sent asynchronously using pool threads it is possible to close 
+            this appender before all the queued events have been sent.
+            When closing the appender attempts to wait until all the queued events have been sent, but 
+            this will timeout after 30 seconds regardless.</para>
+            <para>
+            If this appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for. If the runtime terminates the threads before
+            the queued events have been sent then they will be lost. To ensure that all events
+            are sent the appender must be closed before the application exits. See 
+            <see cref="M:log4net.Core.LoggerManager.Shutdown"/> for details on how to shutdown
+            log4net programmatically.</para>
+            </remarks>
+            <seealso cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemotingAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            The events are not sent immediately. They are scheduled to be sent
+            using a pool thread. The effect is that the send occurs asynchronously.
+            This is very important for a number of non obvious reasons. The remoting
+            infrastructure will flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the 
+            remoting boundary. If the server is not contactable then
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from
+            having side effects on the calling application the remoting call must be made
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then
+            the events will block in the thread pool manager until a thread is available.
+            </remarks>
+            <param name="events">The events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.OnClose">
+            <summary>
+            Override base class close.
+            </summary>
+            <remarks>
+            <para>
+            This method waits while there are queued work items. The events are
+            sent asynchronously using <see cref="T:System.Threading.ThreadPool"/> work items. These items
+            will be sent once a thread pool thread is available to send them, therefore
+            it is possible to close the appender before all the queued events have been
+            sent.</para>
+            <para>
+            This method attempts to wait until all the queued events have been sent, but this 
+            method will timeout after 30 seconds regardless.</para>
+            <para>
+            If the appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>
+            event has fired it may not be possible to send all the queued events. During process
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>
+            event handler is allowed to run for.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.BeginAsyncSend">
+            <summary>
+            A work item is being queued into the thread pool
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.EndAsyncSend">
+            <summary>
+            A work item from the thread pool has completed
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.SendBufferCallback(System.Object)">
+            <summary>
+            Send the contents of the buffer to the remote sink.
+            </summary>
+            <remarks>
+            This method is designed to be used with the <see cref="T:System.Threading.ThreadPool"/>.
+            This method expects to be passed an array of <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the state param.
+            </remarks>
+            <param name="state">the logging events to send</param>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">
+            <summary>
+            The URL of the remote sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">
+            <summary>
+            The local proxy (.NET remoting) for the remote logging sink.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_queuedCallbackCount">
+            <summary>
+            The number of queued callbacks currently waiting or executing
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RemotingAppender.m_workQueueEmptyEvent">
+            <summary>
+            Event used to signal when there are no queued work items
+            </summary>
+            <remarks>
+            This event is set when there are no queued work items. In this
+            state it is safe to close the appender.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RemotingAppender.Sink">
+            <summary>
+            Gets or sets the URL of the well-known object that will accept 
+            the logging events.
+            </summary>
+            <value>
+            The well-known URL of the remote sink.
+            </value>
+            <remarks>
+            <para>
+            The URL of the remoting sink that will accept logging events.
+            The sink must implement the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>
+            interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink">
+            <summary>
+            Interface used to deliver <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            This interface must be implemented by a remoting sink
+            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used
+            to deliver logging events to the sink.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RemotingAppender.IRemoteLoggingSink.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Delivers logging events to the remote sink
+            </summary>
+            <param name="events">Array of events to log.</param>
+            <remarks>
+            <para>
+            Delivers logging events to the remote sink
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender">
+            <summary>
+            Appender that rolls log files based on size or date or both.
+            </summary>
+            <remarks>
+            <para>
+            RollingFileAppender can roll log files based on size or date or both
+            depending on the setting of the <see cref="P:log4net.Appender.RollingFileAppender.RollingStyle"/> property.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Size"/> the log file will be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Date"/> the log file will be rolled
+            once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/> the log file will be
+            rolled once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property
+            is crossed, but within a date boundary the file will also be rolled
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> the log file will be rolled when
+            the appender is configured. This effectively means that the log file can be
+            rolled once per program execution.
+            </para>
+            <para>
+            A of few additional optional features have been added:
+            <list type="bullet">
+            <item>Attach date pattern for current log file <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/></item>
+            <item>Backup number increments for newer files <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/></item>
+            <item>Infinite number of backups by file size <see cref="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups"/></item>
+            </list>
+            </para>
+            
+            <note>
+            <para>
+            For large or infinite numbers of backup files a <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> 
+            greater than zero is highly recommended, otherwise all the backup files need
+            to be renamed each time a new backup is created.
+            </para>
+            <para>
+            When Date/Time based rolling is used setting <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> 
+            to <see langword="true"/> will reduce the number of file renamings to few or none.
+            </para>
+            </note>
+            
+            <note type="caution">
+            <para>
+            Changing <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> or <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> without clearing
+            the log file directory of backup files will cause unexpected and unwanted side effects.  
+            </para>
+            </note>
+            
+            <para>
+            If Date/Time based rolling is enabled this appender will attempt to roll existing files
+            in the directory without a Date/Time tag based on the last write date of the base log file.
+            The appender only rolls the log file when a message is logged. If Date/Time based rolling 
+            is enabled then the appender will not roll the log file at the Date/Time boundary but
+            at the point when the next message is logged after the boundary has been crossed.
+            </para>
+            
+            <para>
+            The <see cref="T:log4net.Appender.RollingFileAppender"/> extends the <see cref="T:log4net.Appender.FileAppender"/> and
+            has the same behavior when opening the log file.
+            The appender will first try to open the file for writing when <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>
+            is called. This will typically be during configuration.
+            If the file cannot be opened for writing the appender will attempt
+            to open the file again each time a message is logged to the appender.
+            If the file cannot be opened for writing when a message is logged then
+            the message will be discarded by this appender.
+            </para>
+            <para>
+            When rolling a backup file necessitates deleting an older backup file the
+            file to be deleted is moved to a temporary name before being deleted.
+            </para>
+            
+            <note type="caution">
+            <para>
+            A maximum number of backup files when rolling on date/time boundaries is not supported.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+            <author>Edward Smit</author>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.RollingFileAppender"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Finalize">
+            <summary>
+            Cleans up all resources used by this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.declaringType">
+            <summary>
+            The fully qualified type of the RollingFileAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">
+            <summary>
+            Sets the quiet writer being used.
+            </summary>
+            <remarks>
+            This method can be overridden by sub classes.
+            </remarks>
+            <param name="writer">the writer to set</param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Write out a logging event.
+            </summary>
+            <param name="loggingEvent">the event to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent[])">
+            <summary>
+            Write out an array of logging events.
+            </summary>
+            <param name="loggingEvents">the events to write to file.</param>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.AdjustFileBeforeAppend">
+            <summary>
+            Performs any required rolling before outputting the next event
+            </summary>
+            <remarks>
+            <para>
+            Handles append time behavior for RollingFileAppender.  This checks
+            if a roll over either by date (checked first) or time (checked second)
+            is need and then appends to the file last.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">
+            <summary>
+            Creates and opens the file for logging.  If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/>
+            is false then the fully qualified name is determined and used.
+            </summary>
+            <param name="fileName">the name of the file to open</param>
+            <param name="append">true to append to existing file</param>
+            <remarks>
+            <para>This method will ensure that the directory structure
+            for the <paramref name="fileName"/> specified exists.</para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetNextOutputFileName(System.String)">
+            <summary>
+            Get the current output file name
+            </summary>
+            <param name="fileName">the base file name</param>
+            <returns>the output file name</returns>
+            <remarks>
+            The output file name is based on the base fileName specified.
+            If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> is set then the output 
+            file name is the same as the base file passed in. Otherwise
+            the output file depends on the date pattern, on the count
+            direction or both.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DetermineCurSizeRollBackups">
+            <summary>
+            Determines curSizeRollBackups (only within the current roll point)
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">
+            <summary>
+            Generates a wildcard pattern that can be used to find all files
+            that are similar to the base file name.
+            </summary>
+            <param name="baseFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">
+            <summary>
+            Builds a list of filenames for all files matching the base filename plus a file
+            pattern.
+            </summary>
+            <param name="baseFilePath"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">
+            <summary>
+            Initiates a roll over if needed for crossing a date boundary since the last run.
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">
+            <summary>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            </summary>
+            <remarks>
+            <para>
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
+            The following is done
+            <list type="bullet">
+            <item>determine curSizeRollBackups (only within the current roll point)</item>
+            <item>initiates a roll over if needed for crossing a date boundary since the last run.</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">
+            <summary>
+            Does the work of bumping the 'current' file counter higher
+            to the highest count when an incremental file name is seen.
+            The highest count is either the first file (when count direction
+            is greater than 0) or the last file (when count direction less than 0).
+            In either case, we want to know the highest count that is present.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="curFileName"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.GetBackUpIndex(System.String)">
+            <summary>
+            Attempts to extract a number from the end of the file name that indicates
+            the number of the times the file has been rolled over.
+            </summary>
+            <remarks>
+            Certain date pattern extensions like yyyyMMdd will be parsed as valid backup indexes.
+            </remarks>
+            <param name="curFileName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">
+            <summary>
+            Takes a list of files and a base file name, and looks for 
+            'incremented' versions of the base file.  Bumps the max
+            count up to the highest count seen.
+            </summary>
+            <param name="baseFile"></param>
+            <param name="arrayFiles"></param>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod(System.String)">
+            <summary>
+            Calculates the RollPoint for the datePattern supplied.
+            </summary>
+            <param name="datePattern">the date pattern to calculate the check period for</param>
+            <returns>The RollPoint that is most accurate for the date pattern supplied</returns>
+            <remarks>
+            Essentially the date pattern is examined to determine what the
+            most suitable roll point is. The roll point chosen is the roll point
+            with the smallest period that can be detected using the date pattern
+            supplied. i.e. if the date pattern only outputs the year, month, day 
+            and hour then the smallest roll point that can be detected would be
+            and hourly roll point as minutes could not be detected.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Sets initial conditions including date/time roll over information, first check,
+            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize
+            the current number of backups.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.CombinePath(System.String,System.String)">
+            <summary>
+            
+            </summary>
+            <param name="path1"></param>
+            <param name="path2">.1, .2, .3, etc.</param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime(System.Boolean)">
+            <summary>
+            Rollover the file(s) to date/time tagged file(s).
+            </summary>
+            <param name="fileIsOpen">set to true if the file to be rolled is currently open</param>
+            <remarks>
+            <para>
+            Rollover the file(s) to date/time tagged file(s).
+            Resets curSizeRollBackups. 
+            If fileIsOpen is set then the new file is opened (through SafeOpenFile).
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">
+            <summary>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>.
+            </summary>
+            <param name="fromFile">Name of existing file to roll.</param>
+            <param name="toFile">New name for file.</param>
+            <remarks>
+            <para>
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. It
+            also checks for existence of target file and deletes if it does.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.FileExists(System.String)">
+            <summary>
+            Test if a file exists at a specified path
+            </summary>
+            <param name="path">the path to the file</param>
+            <returns>true if the file exists</returns>
+            <remarks>
+            <para>
+            Test if a file exists at a specified path
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">
+            <summary>
+            Deletes the specified file if it exists.
+            </summary>
+            <param name="fileName">The file to delete.</param>
+            <remarks>
+            <para>
+            Delete a file if is exists.
+            The file is first moved to a new filename then deleted.
+            This allows the file to be removed even when it cannot
+            be deleted, but it still can be moved.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">
+            <summary>
+            Implements file roll base on file size.
+            </summary>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. Moreover, <c>File</c> is
+            renamed <c>File.1</c> and closed.
+            </para>
+            <para>
+            A new file is created to receive further log output.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverRenameFiles(System.String)">
+            <summary>
+            Implements file roll.
+            </summary>
+            <param name="baseFileName">the base name to rename</param>
+            <remarks>
+            <para>
+            If the maximum number of size based backups is reached
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
+            file is deleted -- its index determined by the sign of countDirection.
+            If <c>countDirection</c> &lt; 0, then files
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
+            are renamed to {<c>File.2</c>, ...,
+            <c>File.curSizeRollBackups</c>}. 
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> is equal to zero, then the
+            <c>File</c> is truncated with no backup files created.
+            </para>
+            <para>
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is
+            renamed if needed and no files are deleted.
+            </para>
+            <para>
+            This is called by <see cref="M:log4net.Appender.RollingFileAppender.RollOverSize"/> to rename the files.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">
+            <summary>
+            Get the start time of the next window for the current rollpoint
+            </summary>
+            <param name="currentDateTime">the current date</param>
+            <param name="rollPoint">the type of roll point we are working with</param>
+            <returns>the start time for the next roll point an interval after the currentDateTime date</returns>
+            <remarks>
+            <para>
+            Returns the date of the next roll point after the currentDateTime date passed to the method.
+            </para>
+            <para>
+            The basic strategy is to subtract the time parts that are less significant
+            than the rollpoint from the current time. This should roll the time back to
+            the start of the time window for the current rollpoint. Then we add 1 window
+            worth of time and get the start time of the next window for the rollpoint.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">
+            <summary>
+            This object supplies the current date/time.  Allows test code to plug in
+            a method to control this class when testing date/time based rolling. The default
+            implementation uses the underlying value of DateTime.Now.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">
+            <summary>
+            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> 
+            meaning daily rollover.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">
+            <summary>
+            The actual formatted filename that is currently being written to
+            or will be the file transferred to on roll over
+            (based on staticLogFileName).
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">
+            <summary>
+            The timestamp when we shall next recompute the filename.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_now">
+            <summary>
+            Holds date of last roll over
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">
+            <summary>
+            The type of rolling done
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">
+            <summary>
+            The default maximum file size is 10MB
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">
+            <summary>
+            There is zero backup files by default
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">
+            <summary>
+            How many sized based backups have been made so far
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">
+            <summary>
+            The rolling file count direction. 
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">
+            <summary>
+            The rolling mode used in this appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">
+            <summary>
+            Cache flag set if we are rolling by date.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">
+            <summary>
+            Cache flag set if we are rolling by size.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">
+            <summary>
+            Value indicating whether to always log to the same file.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_preserveLogFileNameExtension">
+            <summary>
+            Value indicating whether to preserve the file name extension when rolling.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">
+            <summary>
+            FileName provided in configuration.  Used for rolling properly
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.m_mutexForRolling">
+            <summary>
+            A mutex that is used to lock rolling of files.
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DateTimeStrategy">
+            <summary>
+            Gets or sets the strategy for determining the current date and time. The default
+            implementation is to use LocalDateTime which internally calls through to DateTime.Now. 
+            DateTime.UtcNow may be used on frameworks newer than .NET 1.0 by specifying
+            <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </summary>
+            <value>
+            An implementation of the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> interface which returns the current date and time.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> used to return the current date and time.
+            </para>
+            <para>
+            There are two built strategies for determining the current date and time, 
+            <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>
+            and <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.
+            </para>
+            <para>
+            The default strategy is <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">
+            <summary>
+            Gets or sets the date pattern to be used for generating file names
+            when rolling over on date.
+            </summary>
+            <value>
+            The date pattern to be used for generating file names when rolling 
+            over on date.
+            </value>
+            <remarks>
+            <para>
+            Takes a string in the same format as expected by 
+            <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.
+            </para>
+            <para>
+            This property determines the rollover schedule when rolling over
+            on date.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">
+            <summary>
+            Gets or sets the maximum number of backup files that are kept before
+            the oldest is erased.
+            </summary>
+            <value>
+            The maximum number of backup files that are kept before the oldest is
+            erased.
+            </value>
+            <remarks>
+            <para>
+            If set to zero, then there will be no backup files and the log file 
+            will be truncated when it reaches <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  
+            </para>
+            <para>
+            If a negative number is supplied then no deletions will be made.  Note 
+            that this could result in very slow performance as a large number of 
+            files are rolled over unless <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> is used.
+            </para>
+            <para>
+            The maximum applies to <b>each</b> time based group of files and 
+            <b>not</b> the total.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size in bytes that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except
+            that it is required for differentiating the setter taking a
+            <see cref="T:System.Int64"/> argument from the setter taking a <see cref="T:System.String"/> 
+            argument.
+            </para>
+            <para>
+            The default maximum file size is 10MB (10*1024*1024).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">
+            <summary>
+            Gets or sets the maximum size that the output file is allowed to reach
+            before being rolled over to backup files.
+            </summary>
+            <value>
+            The maximum size that the output file is allowed to reach before being 
+            rolled over to backup files.
+            </value>
+            <remarks>
+            <para>
+            This property allows you to specify the maximum size with the
+            suffixes "KB", "MB" or "GB" so that the size is interpreted being 
+            expressed respectively in kilobytes, megabytes or gigabytes. 
+            </para>
+            <para>
+            For example, the value "10KB" will be interpreted as 10240 bytes.
+            </para>
+            <para>
+            The default maximum file size is 10MB.
+            </para>
+            <para>
+            If you have the option to set the maximum file size programmatically
+            consider using the <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/> property instead as this
+            allows you to set the size in bytes as a <see cref="T:System.Int64"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">
+            <summary>
+            Gets or sets the rolling file count direction. 
+            </summary>
+            <value>
+            The rolling file count direction.
+            </value>
+            <remarks>
+            <para>
+            Indicates if the current file is the lowest numbered file or the
+            highest numbered file.
+            </para>
+            <para>
+            By default newer files have lower numbers (<see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &lt; 0),
+            i.e. log.1 is most recent, log.5 is the 5th backup, etc...
+            </para>
+            <para>
+            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 does the opposite i.e.
+            log.1 is the first backup made, log.5 is the 5th backup made, etc.
+            For infinite backups use <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 to reduce 
+            rollover costs.
+            </para>
+            <para>The default file count direction is -1.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">
+            <summary>
+            Gets or sets the rolling style.
+            </summary>
+            <value>The rolling style.</value>
+            <remarks>
+            <para>
+            The default rolling style is <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/>.
+            </para>
+            <para>
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> this appender's
+            <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is set to <c>false</c>, otherwise
+            the appender would append to a single file rather than rolling
+            the file each time it is opened.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.PreserveLogFileNameExtension">
+            <summary>
+            Gets or sets a value indicating whether to preserve the file name extension when rolling.
+            </summary>
+            <value>
+            <c>true</c> if the file name extension should be preserved.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is rolled to file.log.yyyy-MM-dd or file.log.curSizeRollBackup.
+            However, under Windows the new file name will loose any program associations as the
+            extension is changed. Optionally file.log can be renamed to file.yyyy-MM-dd.log or
+            file.curSizeRollBackup.log to maintain any program associations.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">
+            <summary>
+            Gets or sets a value indicating whether to always log to
+            the same file.
+            </summary>
+            <value>
+            <c>true</c> if always should be logged to the same file, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            By default file.log is always the current file.  Optionally
+            file.log.yyyy-mm-dd for current formatted datePattern can by the currently
+            logging file (or file.log.curSizeRollBackup or even
+            file.log.yyyy-mm-dd.curSizeRollBackup).
+            </para>
+            <para>
+            This will make time based rollovers with a large number of backups 
+            much faster as the appender it won't have to rename all the backups!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">
+            <summary>
+            Style of rolling to use
+            </summary>
+            <remarks>
+            <para>
+            Style of rolling to use
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Once">
+            <summary>
+            Roll files once per program execution
+            </summary>
+            <remarks>
+            <para>
+            Roll files once per program execution.
+            Well really once each time this appender is
+            configured.
+            </para>
+            <para>
+            Setting this option also sets <c>AppendToFile</c> to
+            <c>false</c> on the <c>RollingFileAppender</c>, otherwise
+            this appender would just be a normal file appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">
+            <summary>
+            Roll files based only on the size of the file
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">
+            <summary>
+            Roll files based only on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">
+            <summary>
+            Roll files based on both the size and date of the file
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">
+            <summary>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </summary>
+            <remarks>
+            <para>
+            The code assumes that the following 'time' constants are in a increasing sequence.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.InvalidRollPoint">
+            <summary>
+            Roll the log not based on the date
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMinute">
+            <summary>
+            Roll the log for each minute
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfHour">
+            <summary>
+            Roll the log for each hour
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HalfDay">
+            <summary>
+            Roll the log twice a day (midday and midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfDay">
+            <summary>
+            Roll the log each day (midnight)
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfWeek">
+            <summary>
+            Roll the log each week
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMonth">
+            <summary>
+            Roll the log each month
+            </summary>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.IDateTime">
+            <summary>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            </summary>
+            <remarks>
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
+            Used primarily to allow test classes to plug themselves in so they can
+            supply test date/times.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.IDateTime.Now">
+            <summary>
+            Gets the <i>current</i> time.
+            </summary>
+            <value>The <i>current</i> time.</value>
+            <remarks>
+            <para>
+            Gets the <i>current</i> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.LocalDateTime">
+            <summary>
+            Default implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time.
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.LocalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.RollingFileAppender.UniversalDateTime">
+            <summary>
+            Implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time as the coordinated universal time (UTC).
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.RollingFileAppender.UniversalDateTime.Now">
+            <summary>
+            Gets the <b>current</b> time.
+            </summary>
+            <value>The <b>current</b> time.</value>
+            <remarks>
+            <para>
+            Gets the <b>current</b> time.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender">
+            <summary>
+            Send an e-mail when a specific logging event occurs, typically on errors 
+            or fatal errors.
+            </summary>
+            <remarks>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            <note type="caution">
+            Authentication and setting the server Port are only available on the MS .NET 1.1 runtime.
+            For these features to be enabled you need to ensure that you are using a version of
+            the log4net assembly that is built against the MS .NET 1.1 framework and that you are
+            running the your application on the MS .NET 1.1 runtime. On all other platforms only sending
+            unauthenticated messages to a server listening on port 25 (the default) is supported.
+            </note>
+            <para>
+            Authentication is supported by setting the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property to
+            either <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> or <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>.
+            If using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> authentication then the <see cref="P:log4net.Appender.SmtpAppender.Username"/>
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> properties must also be set.
+            </para>
+            <para>
+            To set the SMTP server port use the <see cref="P:log4net.Appender.SmtpAppender.Port"/> property. The default port is 25.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.SendEmail(System.String)">
+            <summary>
+            Send the email message
+            </summary>
+            <param name="messageBody">the body text to include in the mail</param>
+        </member>
+        <member name="M:log4net.Appender.SmtpAppender.MaybeTrimSeparators(System.String)">
+            <summary>
+              trims leading and trailing commas or semicolons
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.To">
+            <summary>
+            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).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Cc">
+            <summary>
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses 
+            that will be carbon copied (use semicolon on .NET 1.1 and comma for later versions).
+            </summary>
+            <value>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </value>
+            <remarks>
+            <para>
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.
+            </para>
+            <para>
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Bcc">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses
+            that will be blind carbon copied.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of recipient e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SmtpHost">
+            <summary>
+            Gets or sets the name of the SMTP relay mail server to use to send 
+            the e-mail messages.
+            </summary>
+            <value>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </value>
+            <remarks>
+            <para>
+            The name of the e-mail relay server. If SmtpServer is not set, the 
+            name of the local SMTP server is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.LocationInfo">
+            <summary>
+            Obsolete
+            </summary>
+            <remarks>
+            Use the BufferingAppenderSkeleton Fix methods instead 
+            </remarks>
+            <remarks>
+            <para>
+            Obsolete property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Authentication">
+            <summary>
+            The mode to use to authentication with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            Valid Authentication mode values are: <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>, 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, and <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>. 
+            The default value is <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>. When using 
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> you must specify the <see cref="P:log4net.Appender.SmtpAppender.Username"/> 
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> to use to authenticate.
+            When using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/> the Windows credentials for the current
+            thread, if impersonating, or the process will be used to authenticate. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Username">
+            <summary>
+            The username to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the username will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Password">
+            <summary>
+            The password to use to authenticate with the SMTP server
+            </summary>
+            <remarks>
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when 
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, 
+            otherwise the password will be ignored. 
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Port">
+            <summary>
+            The port on which the SMTP server is listening
+            </summary>
+            <remarks>
+            <note type="caution">Server Port is only available on the MS .NET 1.1 runtime.</note>
+            <para>
+            The port on which the SMTP server is listening. The default
+            port is <c>25</c>. The Port can only be changed when running on
+            the MS .NET 1.1 runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.Priority">
+            <summary>
+            Gets or sets the priority of the e-mail message
+            </summary>
+            <value>
+            One of the <see cref="T:System.Net.Mail.MailPriority"/> values.
+            </value>
+            <remarks>
+            <para>
+            Sets the priority of the e-mails generated by this
+            appender. The default priority is <see cref="F:System.Net.Mail.MailPriority.Normal"/>.
+            </para>
+            <para>
+            If you are using this appender to report errors then
+            you may want to set the priority to <see cref="F:System.Net.Mail.MailPriority.High"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.EnableSsl">
+            <summary>
+            Enable or disable use of SSL when sending e-mail message
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.ReplyTo">
+            <summary>
+            Gets or sets the reply-to e-mail address.
+            </summary>
+            <remarks>
+            This is available on MS .NET 2.0 runtime and higher
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.SubjectEncoding">
+            <summary>
+            Gets or sets the subject encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.BodyEncoding">
+            <summary>
+            Gets or sets the body encoding to be used.
+            </summary>
+            <remarks>
+            The default encoding is the operating system's current ANSI codepage.
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpAppender.SmtpAuthentication">
+            <summary>
+            Values for the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property.
+            </summary>
+            <remarks>
+            <para>
+            SMTP authentication modes.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None">
+            <summary>
+            No authentication
+            </summary>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic">
+            <summary>
+            Basic authentication.
+            </summary>
+            <remarks>
+            Requires a username and password to be supplied
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm">
+            <summary>
+            Integrated authentication
+            </summary>
+            <remarks>
+            Uses the Windows credentials from the current thread or process to authenticate.
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.SmtpPickupDirAppender">
+            <summary>
+            Send an email when a specific logging event occurs, typically on errors 
+            or fatal errors. Rather than sending via smtp it writes a file into the
+            directory specified by <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>. This allows services such
+            as the IIS SMTP agent to manage sending the messages.
+            </summary>
+            <remarks>
+            <para>
+            The configuration for this appender is identical to that of the <c>SMTPAppender</c>,
+            except that instead of specifying the <c>SMTPAppender.SMTPHost</c> you specify
+            <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>.
+            </para>
+            <para>
+            The number of logging events delivered in this e-mail depend on
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
+            <see cref="T:log4net.Appender.SmtpPickupDirAppender"/> keeps only the last
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its 
+            cyclic buffer. This keeps memory requirements at a reasonable level while 
+            still delivering useful application context.
+            </para>
+            </remarks>
+            <author>Niall Daley</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.SendBuffer(log4net.Core.LoggingEvent[])">
+            <summary>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </summary>
+            <param name="events">The logging events to send.</param>
+            <remarks>
+            <para>
+            Sends the contents of the cyclic buffer as an e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions">
+            <summary>
+            Activate the options on this appender. 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.SmtpPickupDirAppender.m_securityContext">
+            <summary>
+            The security context to use for privileged calls
+            </summary>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.To">
+            <summary>
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses.
+            </summary>
+            <value>
+            A semicolon-delimited list of e-mail addresses.
+            </value>
+            <remarks>
+            <para>
+            A semicolon-delimited list of e-mail addresses.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.From">
+            <summary>
+            Gets or sets the e-mail address of the sender.
+            </summary>
+            <value>
+            The e-mail address of the sender.
+            </value>
+            <remarks>
+            <para>
+            The e-mail address of the sender.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.Subject">
+            <summary>
+            Gets or sets the subject line of the e-mail message.
+            </summary>
+            <value>
+            The subject line of the e-mail message.
+            </value>
+            <remarks>
+            <para>
+            The subject line of the e-mail message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.PickupDir">
+            <summary>
+            Gets or sets the path to write the messages to.
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the path to write the messages to. This should be the same
+            as that used by the agent sending the messages.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.FileExtension">
+            <summary>
+            Gets or sets the file extension for the generated files
+            </summary>
+            <value>
+            The file extension for the generated files
+            </value>
+            <remarks>
+            <para>
+            The file extension for the generated files
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.
+            </value>
+            <remarks>
+            <para>
+            Unless a <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> specified here for this appender
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
+            security context to use. The default behavior is to use the security context
+            of the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender">
+            <summary>
+            Appender that allows clients to connect via Telnet to receive log messages
+            </summary>
+            <remarks>	
+            <para>
+            The TelnetAppender accepts socket connections and streams logging messages
+            back to the client.  
+            The output is provided in a telnet-friendly way so that a log can be monitored 
+            over a TCP/IP socket.
+            This allows simple remote monitoring of application logging.
+            </para>
+            <para>
+            The default <see cref="P:log4net.Appender.TelnetAppender.Port"/> is 23 (the telnet port).
+            </para>
+            </remarks>
+            <author>Keith Long</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TelnetAppender.declaringType">
+            <summary>
+            The fully qualified type of the TelnetAppender class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.OnClose">
+            <summary>
+            Overrides the parent method to close the socket handler
+            </summary>
+            <remarks>
+            <para>
+            Closes all the outstanding connections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.ActivateOptions">
+            <summary>
+            Initialize the appender based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Create the socket handler and wait for connections
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to each connected client.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to each connected client.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.Port">
+            <summary>
+            Gets or sets the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </summary>
+            <value>
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> 
+            indicating the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.
+            </value>
+            <remarks>
+            <para>
+            The default value is 23 (the telnet port).
+            </para>
+            </remarks>
+            <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>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler">
+            <summary>
+            Helper class to manage connected clients
+            </summary>
+            <remarks>
+            <para>
+            The SocketHandler class is used to accept connections from
+            clients.  It is threaded so that clients can connect/disconnect
+            asynchronously.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.#ctor(System.Int32)">
+            <summary>
+            Opens a new server port on <paramref ref="port"/>
+            </summary>
+            <param name="port">the local port to listen on for connections</param>
+            <remarks>
+            <para>
+            Creates a socket handler on the specified local server port.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Send(System.String)">
+            <summary>
+            Sends a string message to each of the connected clients
+            </summary>
+            <param name="message">the text to send</param>
+            <remarks>
+            <para>
+            Sends a string message to each of the connected clients
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.AddClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Add a client to the internal clients list
+            </summary>
+            <param name="client">client to add</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.RemoveClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">
+            <summary>
+            Remove a client from the internal clients list
+            </summary>
+            <param name="client">client to remove</param>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.OnConnect(System.IAsyncResult)">
+            <summary>
+            Callback used to accept a connection on the server socket
+            </summary>
+            <param name="asyncResult">The result of the asynchronous operation</param>
+            <remarks>
+            <para>
+            On connection adds to the list of connections 
+            if there are two many open connections you will be disconnected
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Dispose">
+            <summary>
+            Close all network connections
+            </summary>
+            <remarks>
+            <para>
+            Make sure we close all network connections
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TelnetAppender.SocketHandler.HasConnections">
+            <summary>
+            Test if this handler has active connections
+            </summary>
+            <value>
+            <c>true</c> if this handler has active connections
+            </value>
+            <remarks>
+            <para>
+            This property will be <c>true</c> while this handler has
+            active connections, that is at least one connection that 
+            the handler will attempt to send a message to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient">
+            <summary>
+            Class that represents a client connected to this handler
+            </summary>
+            <remarks>
+            <para>
+            Class that represents a client connected to this handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.#ctor(System.Net.Sockets.Socket)">
+            <summary>
+            Create this <see cref="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient"/> for the specified <see cref="T:System.Net.Sockets.Socket"/>
+            </summary>
+            <param name="socket">the client's socket</param>
+            <remarks>
+            <para>
+            Opens a stream writer on the socket.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Send(System.String)">
+            <summary>
+            Write a string to the client
+            </summary>
+            <param name="message">string to send</param>
+            <remarks>
+            <para>
+            Write a string to the client
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Dispose">
+            <summary>
+            Cleanup the clients connection
+            </summary>
+            <remarks>
+            <para>
+            Close the socket connection.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Appender.TraceAppender">
+            <summary>
+            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <remarks>
+            <para>
+            The application configuration file can be used to control what listeners 
+            are actually used. See the MSDN documentation for the 
+            <see cref="T:System.Diagnostics.Trace"/> class for details on configuring the
+            trace system.
+            </para>
+            <para>
+            Events are written using the <c>System.Diagnostics.Trace.Write(string,string)</c>
+            method. The event's logger name is the default value for the category parameter 
+            of the Write method. 
+            </para>
+            <para>
+            <b>Compact Framework</b><br/>
+            The Compact Framework does not support the <see cref="T:System.Diagnostics.Trace"/>
+            class for any operation except <c>Assert</c>. When using the Compact Framework this
+            appender will write to the <see cref="T:System.Diagnostics.Debug"/> system rather than
+            the Trace system. This appender will therefore behave like the <see cref="T:log4net.Appender.DebugAppender"/>.
+            </para>
+            </remarks>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/>.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/> 
+            with a specified layout.
+            </summary>
+            <param name="layout">The layout to use with this appender.</param>
+            <remarks>
+            <para>
+            Obsolete constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">
+            <summary>
+            Immediate flush means that the underlying writer or output stream
+            will be flushed at the end of each append operation.
+            </summary>
+            <remarks>
+            <para>
+            Immediate flush is slower but ensures that each append request is 
+            actually written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to
+            <c>false</c>, then there is a good chance that the last few
+            logs events are not actually written to persistent media if and
+            when the application crashes.
+            </para>
+            <para>
+            The default value is <c>true</c>.</para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Appender.TraceAppender.m_category">
+            <summary>
+            Defaults to %logger
+            </summary>
+        </member>
+        <member name="M:log4net.Appender.TraceAppender.Flush(System.Int32)">
+            <summary>
+            Flushes any buffered log data.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time to wait for logging events to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">
+            <summary>
+            Gets or sets a value that indicates whether the appender will 
+            flush at the end of each write.
+            </summary>
+            <remarks>
+            <para>The default behavior is to flush at the end of each 
+            write. If the option is set to<c>false</c>, then the underlying 
+            stream can defer writing to physical medium to a later time. 
+            </para>
+            <para>
+            Avoiding the flush operation at the end of each append results 
+            in a performance gain of 10 to 20 percent. However, there is safety
+            trade-off involved in skipping flushing. Indeed, when flushing is
+            skipped, then it is likely that the last few log events will not
+            be recorded on disk when the application exits. This is a high
+            price to pay even for a 20% performance gain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.Category">
+            <summary>
+            The category parameter sent to the Trace method.
+            </summary>
+            <remarks>
+            <para>
+            Defaults to %logger which will use the logger name of the current 
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.
+            </para>
+            <para>
+            </para> 
+            </remarks>
+        </member>
+        <member name="P:log4net.Appender.TraceAppender.RequiresLayout">
+            <summary>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.AliasDomainAttribute">
+            <summary>
+            Assembly level attribute that specifies a domain to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.DomainAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's domain to its repository by
+            specifying this attribute with the name of the target domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required domains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.AliasRepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies a repository to alias to this assembly's repository.
+            </summary>
+            <remarks>
+            <para>
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.RepositoryAttribute"/>,
+            however this can be overridden by an assembly loaded before the target assembly.
+            </para>
+            <para>
+            An assembly can alias another assembly's repository to its repository by
+            specifying this attribute with the name of the target repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may be used
+            as many times as necessary to alias all the required repositories.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.AliasRepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </summary>
+            <param name="name">The repository to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with 
+            the specified repository to alias to this assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.AliasRepositoryAttribute.Name">
+            <summary>
+            Gets or sets the repository to alias to this assemby's repository.
+            </summary>
+            <value>
+            The repository to alias to this assemby's repository.
+            </value>
+            <remarks>
+            <para>
+            The name of the repository to alias to this assemby's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.AliasDomainAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasDomainAttribute"/> class with 
+            the specified domain to alias to this assembly's repository.
+            </summary>
+            <param name="name">The domain to alias to this assemby's repository.</param>
+            <remarks>
+            <para>
+            Obsolete. Use <see cref="T:log4net.Config.AliasRepositoryAttribute"/> instead of <see cref="T:log4net.Config.AliasDomainAttribute"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.BasicConfigurator">
+            <summary>
+            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </summary>
+            <remarks>
+            <para>
+            Allows very simple programmatic configuration of log4net.
+            </para>
+            <para>
+            Only one appender can be configured using this configurator.
+            The appender is set at the root of the hierarchy and all logging
+            events will be delivered to that appender.
+            </para>
+            <para>
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions()"/> method
+            be called after the appenders properties have been configured.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Config.BasicConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the BasicConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.BasicConfigurator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure">
+            <summary>
+            Initializes the log4net system with a default configuration.
+            </summary>
+            <remarks>
+            <para>
+            Initializes the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the log4net system using the specified appenders.
+            </summary>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initializes the log4net system using the specified appender.
+            </summary>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the log4net system using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> with a default configuration.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Initializes the specified repository using a <see cref="T:log4net.Appender.ConsoleAppender"/>
+            that will write to <c>Console.Out</c>. The log messages are
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>
+            layout style.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appender">The appender to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender[])">
+            <summary>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appenders.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="appenders">The appenders to use to log all logging events.</param>
+            <remarks>
+            <para>
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.ConfiguratorAttribute">
+            <summary>
+            Base class for all log4net configuration attributes.
+            </summary>
+            <remarks>
+            This is an abstract class that must be extended by 
+            specific configurators. This attribute allows the
+            configurator to be parameterized by an assembly level
+            attribute.
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">
+            <summary>
+            Constructor used by subclasses.
+            </summary>
+            <param name="priority">the ordering priority for this configurator</param>
+            <remarks>
+            <para>
+            The <paramref name="priority"/> is used to order the configurator
+            attributes before they are invoked. Higher priority configurators are executed
+            before lower priority ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Abstract method implemented by a subclass. When this method is called
+            the subclass should configure the <paramref name="targetRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">
+            <summary>
+            Compare this instance to another ConfiguratorAttribute
+            </summary>
+            <param name="obj">the object to compare to</param>
+            <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>
+            <remarks>
+            <para>
+            Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.
+            Sorts by priority in descending order. Objects with the same priority are
+            randomly ordered.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DomainAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging domain for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            <b>DomainAttribute is obsolete. Use RepositoryAttribute instead of DomainAttribute.</b>
+            </para>
+            <para>
+            Assemblies are mapped to logging domains. Each domain has its own
+            logging repository. This attribute specified on the assembly controls
+            the configuration of the domain. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the repository objects to create for the domain. If 
+            this attribute is not specified and a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> is not specified
+            then the assembly will be part of the default shared logging domain.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.RepositoryAttribute">
+            <summary>
+            Assembly level attribute that specifies the logging repository for the assembly.
+            </summary>
+            <remarks>
+            <para>
+            Assemblies are mapped to logging repository. This attribute specified 
+            on the assembly controls
+            the configuration of the repository. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name
+            of the repository that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>
+            specifies the type of the <see cref="T:log4net.Repository.ILoggerRepository"/> object 
+            to create for the assembly. If this attribute is not specified or a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> 
+            is not specified then the assembly will be part of the default shared logging repository.
+            </para>
+            <para>
+            This attribute can only be specified on the assembly and may only be used
+            once per assembly.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class 
+            with the name of the repository.
+            </summary>
+            <param name="name">The name of the repository.</param>
+            <remarks>
+            <para>
+            Initialize the attribute with the name for the assembly's repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.Name">
+            <summary>
+            Gets or sets the name of the logging repository.
+            </summary>
+            <value>
+            The string name to use as the name of the repository associated with this
+            assembly.
+            </value>
+            <remarks>
+            <para>
+            This value does not have to be unique. Several assemblies can share the
+            same repository. They will share the logging configuration of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.RepositoryAttribute.RepositoryType">
+            <summary>
+            Gets or sets the type of repository to create for this assembly.
+            </summary>
+            <value>
+            The type of repository to create for this assembly.
+            </value>
+            <remarks>
+            <para>
+            The type of the repository to create for the assembly.
+            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            interface.
+            </para>
+            <para>
+            This will be the type of repository created when 
+            the repository is created. If multiple assemblies reference the
+            same repository then the repository is only created once using the
+            <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/> of the first assembly to call into the 
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DomainAttribute.#ctor(System.String)">
+            <summary>
+            Initialize a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class 
+            with the name of the domain.
+            </summary>
+            <param name="name">The name of the domain.</param>
+            <remarks>
+            <para>
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.DOMConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>
+            </para>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="T:log4net.Config.DOMConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>
+            </para>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Config.XmlConfiguratorAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            <para>
+            If neither of the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>
+            properties are set the configuration is loaded from the application's .config file.
+            If set the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property takes priority over the
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property. The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property
+            specifies a path to a file to load the config from. The path is relative to the
+            application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property is used as a postfix to the assembly file name.
+            The config file must be located in the  application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.
+            For example in a console application setting the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> to
+            <c>config</c> has the same effect as not specifying the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or 
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> properties.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.Watch"/> property can be set to cause the <see cref="T:log4net.Config.XmlConfigurator"/>
+            to watch the configuration file for changes.
+            </para>
+            <note>
+            <para>
+            Log4net will only look for assembly level configuration attributes once.
+            When using the log4net assembly level attributes to control the configuration 
+            of log4net you must ensure that the first call to any of the 
+            <see cref="T:log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration
+            attributes. 
+            </para>
+            <para>
+            If you cannot guarantee the order in which log4net calls will be made from 
+            different assemblies you must use programmatic configuration instead, i.e.
+            call the <see cref="M:XmlConfigurator.Configure()"/> method directly.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Configure the repository using the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            The <paramref name="targetRepository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>
+            class otherwise the <see cref="T:log4net.Config.XmlConfigurator"/> will not be able to
+            configure it.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="targetRepository"/> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.</exception>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from the local file system
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configure the specified repository using a <see cref="T:System.IO.FileInfo"/>
+            </summary>
+            <param name="targetRepository">The repository to configure.</param>
+            <param name="configFile">the FileInfo pointing to the config file</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromUri(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attempt to load configuration from a URI
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+        </member>
+        <member name="F:log4net.Config.XmlConfiguratorAttribute.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfiguratorAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile">
+            <summary>
+            Gets or sets the filename of the configuration file.
+            </summary>
+            <value>
+            The filename of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified, this is the name of the configuration file to use with
+            the <see cref="T:log4net.Config.XmlConfigurator"/>. This file path is relative to the
+            <b>application base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>).
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension">
+            <summary>
+            Gets or sets the extension of the configuration file.
+            </summary>
+            <value>
+            The extension of the configuration file.
+            </value>
+            <remarks>
+            <para>
+            If specified this is the extension for the configuration file.
+            The path to the config file is built by using the <b>application 
+            base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>),
+            the <b>assembly file name</b> and the config file extension.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> is set to <c>MyExt</c> then
+            possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or
+            <c>MyClassLibrary.dll.MyExt</c>.
+            </para>
+            <para>
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.Watch">
+            <summary>
+            Gets or sets a value indicating whether to watch the configuration file.
+            </summary>
+            <value>
+            <c>true</c> if the configuration should be watched, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            If this flag is specified and set to <c>true</c> then the framework
+            will watch the configuration file and will reload the config each time 
+            the file is modified.
+            </para>
+            <para>
+            The config file can only be watched if it is loaded from local disk.
+            In a No-Touch (Smart Client) deployment where the application is downloaded
+            from a web server the config file may not reside on the local disk
+            and therefore it may not be able to watch it.
+            </para>
+            <note>
+            Watching configuration is not supported on the SSCLI.
+            </note>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
+            <summary>
+            Class to register for the log4net section of the configuration file
+            </summary>
+            <remarks>
+            The log4net section of the configuration file needs to have a section
+            handler registered. This is the section handler used. It simply returns
+            the XML element that is the root of the section.
+            </remarks>
+            <example>
+            Example of registering the log4net section handler :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<configSections>
+            		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
+            	</configSections>
+            	<log4net>
+            		log4net configuration XML goes here
+            	</log4net>
+            </configuration>
+            </code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
+            <summary>
+            Parses the configuration section.
+            </summary>
+            <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
+            <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>
+            <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>
+            <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.PluginAttribute">
+            <summary>
+            Assembly level attribute that specifies a plugin to attach to 
+            the repository.
+            </summary>
+            <remarks>
+            <para>
+            Specifies the type of a plugin to create and attach to the
+            assembly's repository. The plugin type must implement the
+            <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Plugin.IPluginFactory">
+            <summary>
+            Interface used to create plugins.
+            </summary>
+            <remarks>
+            <para>
+            Interface used to create  a plugin.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPluginFactory.CreatePlugin">
+            <summary>
+            Creates the plugin object.
+            </summary>
+            <returns>the new plugin instance</returns>
+            <remarks>
+            <para>
+            Create and return a new plugin instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="typeName">The type name of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            <para>
+            Where possible use the constructor that takes a <see cref="T:System.Type"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.Type)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class
+            with the specified type.
+            </summary>
+            <param name="type">The type of plugin to create.</param>
+            <remarks>
+            <para>
+            Create the attribute with the plugin type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.CreatePlugin">
+            <summary>
+            Creates the plugin object defined by this attribute.
+            </summary>
+            <remarks>
+            <para>
+            Creates the instance of the <see cref="T:log4net.Plugin.IPlugin"/> object as 
+            specified by this attribute.
+            </para>
+            </remarks>
+            <returns>The plugin object.</returns>
+        </member>
+        <member name="M:log4net.Config.PluginAttribute.ToString">
+            <summary>
+            Returns a representation of the properties of this object.
+            </summary>
+            <remarks>
+            <para>
+            Overrides base class <see cref="M:Object.ToString()" /> method to 
+            return a representation of the properties of this object.
+            </para>
+            </remarks>
+            <returns>A representation of the properties of this object</returns>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.Type">
+            <summary>
+            Gets or sets the type for the plugin.
+            </summary>
+            <value>
+            The type for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type for the plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.PluginAttribute.TypeName">
+            <summary>
+            Gets or sets the type name for the plugin.
+            </summary>
+            <value>
+            The type name for the plugin.
+            </value>
+            <remarks>
+            <para>
+            The type name for the plugin.
+            </para>
+            <para>
+            Where possible use the <see cref="P:log4net.Config.PluginAttribute.Type"/> property instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.SecurityContextProviderAttribute">
+            <summary>
+            Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </summary>
+            <remarks>
+            <para>
+            This attribute may only be used at the assembly scope and can only
+            be used once per assembly.
+            </para>
+            <para>
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>
+            methods.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">
+            <summary>
+            Construct provider attribute with type specified
+            </summary>
+            <param name="providerType">the type of the provider to use</param>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the SecurityContextProvider
+            </summary>
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
+            <param name="targetRepository">The repository to configure.</param>
+            <remarks>
+            <para>
+            Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.
+            Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.SecurityContextProviderAttribute.declaringType">
+            <summary>
+            The fully qualified type of the SecurityContextProviderAttribute class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">
+            <summary>
+            Gets or sets the type of the provider to use.
+            </summary>
+            <value>
+            the type of the provider to use.
+            </value>
+            <remarks>
+            <para>
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator">
+            <summary>
+            Use this class to initialize the log4net environment using an Xml tree.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings
+            stored in the application's configuration file.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure">
+            <summary>
+            Automatically configures the log4net system based on the 
+            application's configuration settings.
+            </summary>
+            <remarks>
+            <para>
+            Each application has a configuration file. This has the
+            same name as the application with '.config' appended.
+            This file is XML and calling this function prompts the
+            configurator to look in that file for a section called
+            <c>log4net</c> that contains the configuration data.
+            </para>
+            <para>
+            To use this method to configure log4net you must specify 
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section
+            handler for the <c>log4net</c> configuration section. See the
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configures log4net using a <c>log4net</c> element
+            </summary>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            </remarks>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the specified configuration file.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Uri)">
+            <summary>
+            Configures log4net using the specified configuration URI.
+            </summary>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.Stream)">
+            <summary>
+            Configures log4net using the specified configuration data stream.
+            </summary>
+            <param name="configStream">A stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the log4net configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML 
+            element.
+            </summary>
+            <remarks>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </remarks>
+            <param name="repository">The repository to configure.</param>
+            <param name="element">The element to parse.</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The log4net configuration file can possible be specified in the application's
+            configuration file (either <c>MyAppName.exe.config</c> for a
+            normal application on <c>Web.config</c> for an ASP.NET application).
+            </para>
+            <para>
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the 
+            configuration. If this file is also a .NET .config file then you must specify 
+            a configuration section for the <c>log4net</c> element otherwise .NET will 
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:
+            <code lang="XML" escaped="true">
+            <configSections>
+            	<section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>
+            </configSections>
+            </code>
+            </para>
+            <example>
+            The following example configures log4net using a configuration file, of which the 
+            location is stored in the application's configuration file :
+            </example>
+            <code lang="C#">
+            using log4net.Config;
+            using System.IO;
+            using System.Configuration;
+            
+            ...
+            
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
+            </code>
+            <para>
+            In the <c>.config</c> file, the path to the log4net can be specified like this :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net-config-file" value="log.config"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Uri)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            URI.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configUri">A URI to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration 
+            file.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configStream">The stream to load the XML configuration from.</param>
+            <remarks>
+            <para>
+            The configuration data must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            Note that this method will NOT close the stream parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
+            <summary>
+            Configures log4net using the file specified, monitors the file for changes 
+            and reloads the configuration if a change is detected.
+            </summary>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, 
+            monitors the file for changes and reloads the configuration if a change 
+            is detected.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The XML file to load the configuration from.</param>
+            <remarks>
+            <para>
+            The configuration file must be valid XML. It must contain
+            at least one element called <c>log4net</c> that holds
+            the configuration data.
+            </para>
+            <para>
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
+            and depends on the behavior of that class.
+            </para>
+            <para>
+            For more information on how to configure log4net using
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.
+            </para>
+            </remarks>
+            <seealso cref="M:Configure(FileInfo)"/>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.InternalConfigureFromXml(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
+            <summary>
+            Configures the specified repository using a <c>log4net</c> element.
+            </summary>
+            <param name="repository">The hierarchy to configure.</param>
+            <param name="element">The element to parse.</param>
+            <remarks>
+            <para>
+            Loads the log4net configuration from the XML element
+            supplied as <paramref name="element"/>.
+            </para>
+            <para>
+            This method is ultimately called by one of the Configure methods 
+            to load the configuration from an <see cref="T:System.Xml.XmlElement"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.m_repositoryName2ConfigAndWatchHandler">
+            <summary>
+            Maps repository names to ConfigAndWatchHandler instances to allow a particular
+            ConfigAndWatchHandler to dispose of its FileSystemWatcher when a repository is 
+            reconfigured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler">
+            <summary>
+            Class used to watch config files.
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="T:System.IO.FileSystemWatcher"/> to monitor
+            changes to a specified file. Because multiple change notifications
+            may be raised when the file is modified, a timer is used to
+            compress the notifications into a single event. The timer
+            waits for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> time before delivering
+            the event notification. If any further <see cref="T:System.IO.FileSystemWatcher"/>
+            change notifications arrive while the timer is waiting it
+            is reset and waits again for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> to
+            elapse.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis">
+            <summary>
+            The default amount of time to wait after receiving notification
+            before reloading the config file.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_configFile">
+            <summary>
+            Holds the FileInfo used to configure the XmlConfigurator
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_repository">
+            <summary>
+            Holds the repository being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_timer">
+            <summary>
+            The timer used to compress the notification events.
+            </summary>
+        </member>
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_watcher">
+            <summary>
+            Watches file for changes. This object should be disposed when no longer
+            needed to free system handles on the watched resources.
+            </summary>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class to
+            watch a specified config file used to configure a repository.
+            </summary>
+            <param name="repository">The repository to configure.</param>
+            <param name="configFile">The configuration file to watch.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">
+            <summary>
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.
+            </summary>
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>
+            <remarks>
+            <para>
+            This handler reloads the configuration from the file when the event is fired.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.OnWatchedFileChange(System.Object)">
+            <summary>
+            Called by the timer when the configuration has been updated.
+            </summary>
+            <param name="state">null</param>
+        </member>
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.Dispose">
+            <summary>
+            Release the handles held by the watcher and timer.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.CompactRepositorySelector">
+            <summary>
+            The implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface suitable
+            for use with the compact framework
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.IRepositorySelector"/> implementation is a simple
+            mapping between repository name and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            object.
+            </para>
+            <para>
+            The .NET Compact Framework 1.0 does not support retrieving assembly
+            level attributes therefore unlike the <c>DefaultRepositorySelector</c>
+            this selector does not examine the calling assembly for attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Core.IRepositorySelector">
+            <summary>
+            Interface used by the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.Core.IRepositorySelector"/> 
+            to specify the policy for selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> 
+            to return to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association. The results of this method must be repeatable, i.e.
+            when called again with the same arguments the result must be the
+            save value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the named <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repositoryName">The name to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            Lookup a named <see cref="T:log4net.Repository.ILoggerRepository"/>. This is the repository created by
+            calling <see cref="M:CreateRepository(string,Type)"/>.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="assembly">The assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>
+            is made is not defined. The implementation may choose any method for
+            this association.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository with the name specified.
+            </summary>
+            <param name="repositoryName">The name to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the name
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same name will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(Assembly, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(Assembly)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>
+            An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances created by 
+            this <see cref="T:log4net.Core.IRepositorySelector"/>.</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Create a new repository selector
+            </summary>
+            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new compact repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
+            </summary>
+            <param name="assembly">not used</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <param name="repositoryName">the name of the repository to lookup</param>
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>
+            <remarks>
+            <para>
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>. The default 
+            repository is <c>log4net-default-repository</c>. Other repositories 
+            must be created using the <see cref="M:CreateRepository(string, Type)"/>.
+            If the named repository does not exist an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> does not exist</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="assembly">not used</param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <paramref name="assembly"/> argument is not used. This selector does not create a
+            separate repository for each assembly. 
+            </para>
+            <para>
+            If the <paramref name="repositoryType"/> is <c>null</c> then the
+            default repository type specified to the constructor is used.
+            </para>
+            <para>
+            As a named repository is not specified the default repository is 
+            returned. The default repository is named <c>log4net-default-repository</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Create a new repository for the repository specified
+            </summary>
+            <param name="repositoryName">the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is null then the default repository type is used.</param>
+            <returns>the repository created</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            <para>
+            If the named repository already exists an exception will be thrown.
+            </para>
+            <para>
+            If <paramref name="repositoryType"/> is <c>null</c> then the default 
+            repository type specified to the constructor is used.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> already exists</exception>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.CompactRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the CompactRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.CompactRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notify the registered listeners that the repository has been created
+            </summary>
+            <param name="repository">The repository that has been created</param>
+            <remarks>
+            <para>
+            Raises the <event cref="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">LoggerRepositoryCreatedEvent</event>
+            event.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.DefaultRepositorySelector">
+            <summary>
+            The default implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Uses attributes defined on the calling assembly to determine how to
+            configure the hierarchy for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.#ctor(System.Type)">
+            <summary>
+            Creates a new repository selector.
+            </summary>
+            <param name="defaultRepositoryType">The type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
+            <remarks>
+            <para>
+            Create an new repository selector.
+            The default type for repositories must be specified,
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null"/>.</exception>
+            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
+            </summary>
+            <param name="repositoryAssembly">The assembly use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <remarks>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and the repository 
+            to create can be overridden by specifying the <see cref="T:log4net.Config.RepositoryAttribute"/> 
+            attribute on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> 
+            implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically configured using 
+            any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
+            the <paramref name="repositoryAssembly"/>.
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.String)">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.</returns>
+            <remarks>
+            <para>
+            Returns the named repository. If <paramref name="repositoryName"/> is <c>null</c>
+            a <see cref="T:System.ArgumentNullException"/> is thrown. If the repository 
+            does not exist a <see cref="T:log4net.Core.LogException"/> is thrown.
+            </para>
+            <para>
+            Use <see cref="M:CreateRepository(string, Type)"/> to create a repository.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> does not exist.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Create a new repository for the assembly specified 
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type,System.String,System.Boolean)">
+            <summary>
+            Creates a new repository for the assembly specified.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryName">The name to assign to the created repository</param>
+            <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
+            <returns>The repository created.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            <para>
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
+            the repository to create can be overridden by specifying the
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the 
+            <paramref name="repositoryAssembly"/>.  The default values are to use the 
+            <paramref name="repositoryType"/> implementation of the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> 
+            attributes defined on the <paramref name="repositoryAssembly"/>.
+            </para>
+            <para>
+            If a repository for the <paramref name="repositoryAssembly"/> already exists
+            that repository will be returned. An error will not be raised and that 
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the
+            assembly may be used to override the repository type specified in 
+            <paramref name="repositoryType"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a new repository for the specified repository.
+            </summary>
+            <param name="repositoryName">The repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            If this param is <see langword="null"/> then the default repository type is used.</param>
+            <returns>The new repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the
+            same repository specified will return the same repository instance.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ExistsRepository(System.String)">
+            <summary>
+            Test if a named repository exists
+            </summary>
+            <param name="repositoryName">the named repository to check</param>
+            <returns><c>true</c> if the repository exists</returns>
+            <remarks>
+            <para>
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve 
+            a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetAllRepositories">
+            <summary>
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
+            </summary>
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
+            <remarks>
+            <para>
+            Gets an array of all of the repositories created by this selector.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.AliasRepository(System.String,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Aliases a repository to an existing repository.
+            </summary>
+            <param name="repositoryAlias">The repository to alias.</param>
+            <param name="repositoryTarget">The repository that the repository is aliased to.</param>
+            <remarks>
+            <para>
+            The repository specified will be aliased to the repository when created. 
+            The repository must not already exist.
+            </para>
+            <para>
+            When the repository is created it must utilize the same repository type as 
+            the repository it is aliased to, otherwise the aliasing will fail.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="repositoryAlias"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repositoryTarget"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Notifies the registered listeners that the repository has been created.
+            </summary>
+            <param name="repository">The repository that has been created.</param>
+            <remarks>
+            <para>
+            Raises the <see cref="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">
+            <summary>
+            Gets the repository name and repository type for the specified assembly.
+            </summary>
+            <param name="assembly">The assembly that has a <see cref="T:log4net.Config.RepositoryAttribute"/>.</param>
+            <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>
+            <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>
+            <exception cref="T:System.ArgumentNullException"><paramref name="assembly"/> is <see langword="null"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Configures the repository using information from the assembly.
+            </summary>
+            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>
+            attributes which define the configuration for the repository.</param>
+            <param name="repository">The repository to configure.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadPlugins(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined plugins on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to add the plugins to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadAliases(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
+            <summary>
+            Loads the attribute defined aliases on the assembly.
+            </summary>
+            <param name="assembly">The assembly that contains the attributes.</param>
+            <param name="repository">The repository to alias to.</param>
+            <exception cref="T:System.ArgumentNullException">
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>
+            <para>-or-</para>
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>
+            </exception>
+        </member>
+        <member name="F:log4net.Core.DefaultRepositorySelector.declaringType">
+            <summary>
+            The fully qualified type of the DefaultRepositorySelector class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent">
+            <summary>
+            Event to notify that a logger repository has been created.
+            </summary>
+            <value>
+            Event to notify that a logger repository has been created.
+            </value>
+            <remarks>
+            <para>
+            Event raised when a new repository is created.
+            The event source will be this selector. The event args will
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ErrorCode">
+            <summary>
+            Defined error codes that can be passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Values passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.GenericFailure">
+            <summary>
+            A general error
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.WriteFailure">
+            <summary>
+            Error while writing output
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FlushFailure">
+            <summary>
+            Failed to flush file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.CloseFailure">
+            <summary>
+            Failed to close file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.FileOpenFailure">
+            <summary>
+            Unable to open output file
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.MissingLayout">
+            <summary>
+            No layout specified
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ErrorCode.AddressParseFailure">
+            <summary>
+            Failed to parse address
+            </summary>
+        </member>
+        <member name="T:log4net.Core.ExceptionEvaluator">
+            <summary>
+            An evaluator that triggers on an Exception type
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the type of the Exception
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to a Type in <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.    /// 
+            </para>
+            </remarks>
+            <author>Drew Schaeffer</author>
+        </member>
+        <member name="T:log4net.Core.ITriggeringEventEvaluator">
+            <summary>
+            Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action
+            </summary>
+            <remarks>
+            <para>
+            Implementations of this interface allow certain appenders to decide
+            when to perform an appender specific action.
+            </para>
+            <para>
+            The action or behavior triggered is defined by the implementation.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Test if this event triggers the action
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
+            <remarks>
+            <para>
+            Return <c>true</c> if this event triggers the action
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_type">
+            <summary>
+            The type that causes the trigger to fire.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.ExceptionEvaluator.m_triggerOnSubclass">
+            <summary>
+            Causes subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/> to cause the trigger to fire.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor">
+            <summary>
+            Default ctor to allow dynamic creation through a configurator.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor(System.Type,System.Boolean)">
+            <summary>
+            Constructs an evaluator and initializes to trigger on <paramref name="exType"/>
+            </summary>
+            <param name="exType">the type that triggers this evaluator.</param>
+            <param name="triggerOnSubClass">If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.</param>
+        </member>
+        <member name="M:log4net.Core.ExceptionEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the logging event Exception 
+            Type is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the Exception Type of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.ExceptionType">
+            <summary>
+            The type that triggers this evaluator.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.ExceptionEvaluator.TriggerOnSubclass">
+            <summary>
+            If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.IErrorHandler">
+            <summary>
+            Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.
+            </summary>
+            <remarks>
+            <para>
+            Error handling is a particularly tedious to get right because by
+            definition errors are hard to predict and to reproduce. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <param name="errorCode">The error code associated with the error.</param>
+            <remarks>
+            <para>
+            Handles the error and information about the error condition is passed as 
+            a parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String)">
+            <summary>
+            Prints the error message passed as a parameter.
+            </summary>
+            <param name="message">The message associated with the error.</param>
+            <remarks>
+            <para>
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.IFixingRequired">
+            <summary>
+            Interface for objects that require fixing.
+            </summary>
+            <remarks>
+            <para>
+            Interface that indicates that the object requires fixing before it
+            can be taken outside the context of the appender's 
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.
+            </para>
+            <para>
+            When objects that implement this interface are stored 
+            in the context properties maps <see cref="T:log4net.GlobalContext"/>
+            <see cref="P:log4net.GlobalContext.Properties"/> and <see cref="T:log4net.ThreadContext"/>
+            <see cref="P:log4net.ThreadContext.Properties"/> are fixed 
+            (see <see cref="P:log4net.Core.LoggingEvent.Fix"/>) the <see cref="M:log4net.Core.IFixingRequired.GetFixedObject"/>
+            method will be called.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.IFixingRequired.GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a portable instance object that represents the current
+            state of this object. The portable object can be stored
+            and logged from any thread with identical results.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILogger">
+            <summary>
+            Interface that all loggers implement
+            </summary>
+            <remarks>
+            <para>
+            This interface supports logging events and testing if a level
+            is enabled for logging.
+            </para>
+            <para>
+            These methods will not throw exceptions. Note to implementor, ensure
+            that the implementation of these methods cannot allow an exception
+            to be thrown to the caller.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">the exception to log, including its stack trace. Pass <c>null</c> to not log an exception.</param>
+            <remarks>
+            <para>
+            Generates a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.ILogger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="T:log4net.Core.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Name">
+            <summary>
+            Gets the name of the logger.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.ILogger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.ILoggerWrapper">
+            <summary>
+            Base interface for all wrappers
+            </summary>
+            <remarks>
+            <para>
+            Base interface for all wrappers.
+            </para>
+            <para>
+            All wrappers must implement this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Core.ILoggerWrapper.Logger">
+            <summary>
+            Get the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this
+            object. The <c>Logger</c> object may not 
+            be the same object as this object because of logger decorators.
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventHandler">
+            <summary>
+            Delegate used to handle logger repository creation event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Core.IRepositorySelector"/> which created the repository.</param>
+            <param name="e">The <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> event args
+            that holds the <see cref="T:log4net.Repository.ILoggerRepository"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> 
+            event is raised every time a <see cref="T:log4net.Repository.ILoggerRepository"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerRepositoryCreationEventArgs.m_repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggerRepositoryCreationEventArgs.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </summary>
+            <param name="repository">the <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created</param>
+            <remarks>
+            <para>
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggerRepositoryCreationEventArgs.LoggerRepository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </value>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.Level">
+            <summary>
+            Defines the default set of levels recognized by the system.
+            </summary>
+            <remarks>
+            <para>
+            Each <see cref="T:log4net.Core.LoggingEvent"/> has an associated <see cref="T:log4net.Core.Level"/>.
+            </para>
+            <para>
+            Levels have a numeric <see cref="P:log4net.Core.Level.Value"/> that defines the relative 
+            ordering between levels. Two Levels with the same <see cref="P:log4net.Core.Level.Value"/> 
+            are deemed to be equivalent.
+            </para>
+            <para>
+            The levels that are recognized by log4net are set for each <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and each repository can have different levels defined. The levels are stored
+            in the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> on the repository. Levels are
+            looked up by name from the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>.
+            </para>
+            <para>
+            When logging at level INFO the actual level used is not <see cref="F:log4net.Core.Level.Info"/> but
+            the value of <c>LoggerRepository.LevelMap["INFO"]</c>. The default value for this is
+            <see cref="F:log4net.Core.Level.Info"/>, but this can be changed by reconfiguring the level map.
+            </para>
+            <para>
+            Each level has a <see cref="P:log4net.Core.Level.DisplayName"/> in addition to its <see cref="P:log4net.Core.Level.Name"/>. The 
+            <see cref="P:log4net.Core.Level.DisplayName"/> is the string that is written into the output log. By default
+            the display name is the same as the level name, but this can be used to alias levels
+            or to localize the log output.
+            </para>
+            <para>
+            Some of the predefined levels recognized by the system are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Off"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Fatal"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Error"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Warn"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Info"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.Debug"/>.</description>
+            	</item>
+            	<item>
+            		<description><see cref="F:log4net.Core.Level.All"/>.</description>
+            	</item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <param name="displayName">The display name for this level. This may be localized or otherwise different from the name</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>
+            <param name="levelName">The string name of this level.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with
+            the specified level name and value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.ToString">
+            <summary>
+            Returns the <see cref="T:System.String"/> representation of the current 
+            <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <returns>
+            A <see cref="T:System.String"/> representation of the current <see cref="T:log4net.Core.Level"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns the level <see cref="P:log4net.Core.Level.Name"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Equals(System.Object)">
+            <summary>
+            Compares levels.
+            </summary>
+            <param name="o">The object to compare against.</param>
+            <returns><c>true</c> if the objects are equal.</returns>
+            <remarks>
+            <para>
+            Compares the levels of <see cref="T:log4net.Core.Level"/> instances, and 
+            defers to base class if the target object is not a <see cref="T:log4net.Core.Level"/>
+            instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.GetHashCode">
+            <summary>
+            Returns a hash code
+            </summary>
+            <returns>A hash code for the current <see cref="T:log4net.Core.Level"/>.</returns>
+            <remarks>
+            <para>
+            Returns a hash code suitable for use in hashing algorithms and data 
+            structures like a hash table.
+            </para>
+            <para>
+            Returns the hash code of the level <see cref="P:log4net.Core.Level.Value"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.CompareTo(System.Object)">
+            <summary>
+            Compares this instance to a specified object and returns an 
+            indication of their relative values.
+            </summary>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> instance or <see langword="null"/> to compare with this instance.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description>This instance is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description>This instance is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description>
+            			<para>This instance is greater than <paramref name="r"/>.</para>
+            			<para>-or-</para>
+            			<para><paramref name="r"/> is <see langword="null"/>.</para>
+            			</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            <paramref name="r"/> must be an instance of <see cref="T:log4net.Core.Level"/> 
+            or <see langword="null"/>; otherwise, an exception is thrown.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException"><paramref name="r"/> is not a <see cref="T:log4net.Core.Level"/>.</exception>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThan(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_GreaterThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is greater than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is greater than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_LessThanOrEqual(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> 
+            is less than or equal to another specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>
+            <returns>
+            <c>true</c> if <paramref name="l"/> is less than or equal to 
+            <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Equality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have the same value.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is the same as the 
+            value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.op_Inequality(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> 
+            objects have different values.
+            </summary>
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>
+            <returns>
+            <c>true</c> if the value of <paramref name="l"/> is different from
+            the value of <paramref name="r"/>; otherwise, <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.Level.Compare(log4net.Core.Level,log4net.Core.Level)">
+            <summary>
+            Compares two specified <see cref="T:log4net.Core.Level"/> instances.
+            </summary>
+            <param name="l">The first <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <param name="r">The second <see cref="T:log4net.Core.Level"/> to compare.</param>
+            <returns>
+            A 32-bit signed integer that indicates the relative order of the 
+            two values compared. The return value has these meanings:
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Meaning</description>
+            	</listheader>
+            	<item>
+            		<term>Less than zero</term>
+            		<description><paramref name="l"/> is less than <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Zero</term>
+            		<description><paramref name="l"/> is equal to <paramref name="r"/>.</description>
+            	</item>
+            	<item>
+            		<term>Greater than zero</term>
+            		<description><paramref name="l"/> is greater than <paramref name="r"/>.</description>
+            	</item>
+            </list>
+            </returns>
+            <remarks>
+            <para>
+            Compares two levels.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.Level.Off">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Off"/> level designates a higher level than all the rest.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Log4Net_Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Emergency">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. 
+            System unusable, emergencies.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fatal">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fatal"/> level designates very severe error events 
+            that will presumably lead the application to abort.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Alert">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Alert"/> level designates very severe error events. 
+            Take immediate action, alerts.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Critical">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Critical"/> level designates very severe error events. 
+            Critical condition, critical.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Severe">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Severe"/> level designates very severe error events.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Error">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Error"/> level designates error events that might 
+            still allow the application to continue running.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Warn">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Warn"/> level designates potentially harmful 
+            situations.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Notice">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Notice"/> level designates informational messages 
+            that highlight the progress of the application at the highest level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Info">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Info"/> level designates informational messages that 
+            highlight the progress of the application at coarse-grained level.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Debug">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Debug"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Fine">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Fine"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Trace">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Trace"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finer">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finer"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Verbose">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Verbose"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.Finest">
+            <summary>
+            The <see cref="F:log4net.Core.Level.Finest"/> level designates fine-grained informational 
+            events that are most useful to debug an application.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.Level.All">
+            <summary>
+            The <see cref="F:log4net.Core.Level.All"/> level designates the lowest level possible.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.Level.Name">
+            <summary>
+            Gets the name of this level.
+            </summary>
+            <value>
+            The name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.Value">
+            <summary>
+            Gets the value of this level.
+            </summary>
+            <value>
+            The value of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the value of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.Level.DisplayName">
+            <summary>
+            Gets the display name of this level.
+            </summary>
+            <value>
+            The display name of this level.
+            </value>
+            <remarks>
+            <para>
+            Gets the display name of this level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Core.Level"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ReadOnly(log4net.Core.LevelCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>LevelCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>LevelCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>LevelCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <c>LevelCollection</c>.
+            </summary>
+            <param name="c">The <c>LevelCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.Level[])">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Core.Level"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>LevelCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[])">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[],System.Int32)">
+            <summary>
+            Copies the entire <c>LevelCollection</c> to a one-dimensional
+            <see cref="T:log4net.Core.Level"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Add(log4net.Core.Level)">
+            <summary>
+            Adds a <see cref="T:log4net.Core.Level"/> to the end of the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to be added to the end of the <c>LevelCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clear">
+            <summary>
+            Removes all elements from the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Core.LevelCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Contains(log4net.Core.Level)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Core.Level"/> is in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.IndexOf(log4net.Core.Level)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Core.Level"/>
+            in the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to locate in the <c>LevelCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>LevelCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Insert(System.Int32,log4net.Core.Level)">
+            <summary>
+            Inserts an element into the <c>LevelCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Remove(log4net.Core.Level)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Core.Level"/> from the <c>LevelCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to remove from the <c>LevelCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Core.Level"/> was not found in the <c>LevelCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>LevelCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>LevelCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Core.LevelCollection.Enumerator"/> for the entire <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.LevelCollection)">
+            <summary>
+            Adds the elements of another <c>LevelCollection</c> to the current <c>LevelCollection</c>.
+            </summary>
+            <param name="x">The <c>LevelCollection</c> whose elements should be added to the end of the current <c>LevelCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.Level[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> array to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> collection to the current <c>LevelCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>LevelCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Core.Level"/> at the specified index.
+            </summary>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>LevelCollection</c> can contain.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.ILevelCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LevelCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Core.LevelCollection"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.#ctor(log4net.Core.LevelCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Core.LevelCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LevelCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LevelEvaluator">
+            <summary>
+            An evaluator that triggers at a threshold level
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelEvaluator.m_threshold">
+            <summary>
+            The threshold for triggering
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.#ctor(log4net.Core.Level)">
+            <summary>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </summary>
+            <param name="threshold">the threshold to trigger at</param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.
+            </para>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the event level
+            is equal or higher than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelEvaluator.Threshold">
+            <summary>
+            the threshold to trigger at
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.Level"/> that will cause this evaluator to trigger
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the level of the event
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>
+            level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LevelMap">
+            <summary>
+            Mapping between string name and Level object
+            </summary>
+            <remarks>
+            <para>
+            Mapping between string name and <see cref="T:log4net.Core.Level"/> object.
+            This mapping is held separately for each <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The level name is case insensitive.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LevelMap.m_mapName2Level">
+            <summary>
+            Mapping from level name to Level object. The
+            level name is case insensitive
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LevelMap.#ctor">
+            <summary>
+            Construct the level map
+            </summary>
+            <remarks>
+            <para>
+            Construct the level map.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Clear">
+            <summary>
+            Clear the internal maps of all levels
+            </summary>
+            <remarks>
+            <para>
+            Clear the internal maps of all levels
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+            <seealso cref="M:Add(string,int,string)"/>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32,System.String)">
+            <summary>
+            Create a new Level and add it to the map
+            </summary>
+            <param name="name">the string to display for the Level</param>
+            <param name="value">the level value to give to the Level</param>
+            <param name="displayName">the display name to give to the Level</param>
+            <remarks>
+            <para>
+            Create a new Level and add it to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.Add(log4net.Core.Level)">
+            <summary>
+            Add a Level to the map
+            </summary>
+            <param name="level">the Level to add</param>
+            <remarks>
+            <para>
+            Add a Level to the map
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LevelMap.LookupWithDefault(log4net.Core.Level)">
+            <summary>
+            Lookup a named level from the map
+            </summary>
+            <param name="defaultLevel">the name of the level to lookup is taken from this level. 
+            If the level is not set on the map then this level is added</param>
+            <returns>the level in the map with the name specified</returns>
+            <remarks>
+            <para>
+            Lookup a named level from the map. The name of the level to lookup is taken
+            from the <see cref="P:log4net.Core.Level.Name"/> property of the <paramref name="defaultLevel"/>
+            argument.
+            </para>
+            <para>
+            If no level with the specified name is found then the 
+            <paramref name="defaultLevel"/> argument is added to the level map
+            and returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.Item(System.String)">
+            <summary>
+            Lookup a <see cref="T:log4net.Core.Level"/> by name
+            </summary>
+            <param name="name">The name of the Level to lookup</param>
+            <returns>a Level from the map with the name specified</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="T:log4net.Core.Level"/> from the
+            map with the name specified. If the no level is
+            found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LevelMap.AllLevels">
+            <summary>
+            Return all possible levels as a list of Level objects.
+            </summary>
+            <returns>all possible levels as a list of Level objects</returns>
+            <remarks>
+            <para>
+            Return all possible levels as a list of Level objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LocationInfo">
+            <summary>
+            The internal representation of caller location information.
+            </summary>
+            <remarks>
+            <para>
+            This class uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.Type)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class based on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="className">The fully qualified class name.</param>
+            <param name="methodName">The method name.</param>
+            <param name="fileName">The file name.</param>
+            <param name="lineNumber">The line number of the method within the file.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>
+            class with the specified data.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LocationInfo.declaringType">
+            <summary>
+            The fully qualified type of the LocationInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.MethodName">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LocationInfo.StackFrames">
+            <summary>
+            Gets the stack frames from the stack trace of the caller making the log request
+            </summary>
+        </member>
+        <member name="T:log4net.Core.LoggerManager">
+            <summary>
+            Static manager that controls the creation of repositories
+            </summary>
+            <remarks>
+            <para>
+            Static manager that controls the creation of repositories
+            </para>
+            <para>
+            This class is used by the wrapper managers (e.g. <see cref="T:log4net.LogManager"/>)
+            to provide access to the <see cref="T:log4net.Core.ILogger"/> objects.
+            </para>
+            <para>
+            This manager also holds the <see cref="T:log4net.Core.IRepositorySelector"/> that is used to
+            lookup and create repositories. The selector can be set either programmatically using
+            the <see cref="P:log4net.Core.LoggerManager.RepositorySelector"/> property, or by setting the <c>log4net.RepositorySelector</c>
+            AppSetting in the applications config file to the fully qualified type name of the
+            selector to use. 
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#ctor">
+            <summary>
+            Private constructor to prevent instances. Only static methods should be used.
+            </summary>
+            <remarks>
+            <para>
+            Private constructor to prevent instances. Only static methods should be used.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.#cctor">
+            <summary>
+            Hook the shutdown event
+            </summary>
+            <remarks>
+            <para>
+            On the full .NET runtime, the static constructor hooks up the 
+            <c>AppDomain.ProcessExit</c> and <c>AppDomain.DomainUnload</c>> events. 
+            These are used to shutdown the log4net system as the application exits.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.RegisterAppDomainEvents">
+            <summary>
+            Register for ProcessExit and DomainUnload events on the AppDomain
+            </summary>
+            <remarks>
+            <para>
+            This needs to be in a separate method because the events make
+            a LinkDemand for the ControlAppDomain SecurityPermission. Because
+            this is a LinkDemand it is demanded at JIT time. Therefore we cannot
+            catch the exception in the method itself, we have to catch it in the
+            caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.String)">
+            <summary>
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repository">the repository to lookup in</param>
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the named logger does not exist in the
+            specified assembly's repository.
+            </returns>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified assembly's repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <returns>All the defined loggers.</returns>
+            <remarks>
+            <para>
+            The root logger is <b>not</b> included in the returned array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <param name="repositoryAssembly">the assembly to use to lookup the repository</param>
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+            <remarks>
+            <para>
+            Gets the logger for the fully qualified name of the type specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repository">The repository to shutdown.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository for the repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repository">The repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An Exception will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetAllRepositories">
+            <summary>
+            Gets an array of all currently defined repositories.
+            </summary>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+            <remarks>
+            <para>
+            Gets an array of all currently defined repositories.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.GetVersionInfo">
+            <summary>
+            Internal method to get pertinent version info.
+            </summary>
+            <returns>A string of version info.</returns>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnDomainUnload(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggerManager.OnProcessExit(System.Object,System.EventArgs)">
+            <summary>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires
+            </summary>
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
+            <param name="e">null</param>
+            <remarks>
+            <para>
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires.
+            </para>
+            <para>
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.declaringType">
+            <summary>
+            The fully qualified type of the LoggerManager class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerManager.s_repositorySelector">
+            <summary>
+            Initialize the default repository selector
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerManager.RepositorySelector">
+            <summary>
+            Gets or sets the repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </summary>
+            <value>
+            The repository selector used by the <see cref="T:log4net.LogManager"/>.
+            </value>
+            <remarks>
+            <para>
+            The repository selector (<see cref="T:log4net.Core.IRepositorySelector"/>) is used by 
+            the <see cref="T:log4net.LogManager"/> to create and select repositories 
+            (<see cref="T:log4net.Repository.ILoggerRepository"/>).
+            </para>
+            <para>
+            The caller to <see cref="T:log4net.LogManager"/> supplies either a string name 
+            or an assembly (if not supplied the assembly is inferred using 
+            <see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            <para>
+            This context is used by the selector to lookup a specific repository.
+            </para>
+            <para>
+            For the full .NET Framework, the default repository is <c>DefaultRepositorySelector</c>;
+            for the .NET Compact Framework <c>CompactRepositorySelector</c> is the default
+            repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggerWrapperImpl">
+            <summary>
+            Implementation of the <see cref="T:log4net.Core.ILoggerWrapper"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This class should be used as the base for all wrapper implementations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.LoggerWrapperImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Constructs a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Constructs a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggerWrapperImpl.m_logger">
+            <summary>
+            The logger that this object is wrapping
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LoggerWrapperImpl.Logger">
+            <summary>
+            Gets the implementation behind this wrapper object.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Core.ILogger"/> object that this object is implementing.
+            </value>
+            <remarks>
+            <para>
+            The <c>Logger</c> object may not be the same object as this object 
+            because of logger decorators.
+            </para>
+            <para>
+            This gets the actual underlying objects that is used to process
+            the log events.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEventData">
+            <summary>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LoggerName">
+            <summary>
+            The logger name.
+            </summary>
+            <remarks>
+            <para>
+            The logger name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Level">
+            <summary>
+            Level of logging event.
+            </summary>
+            <remarks>
+            <para>
+            Level of logging event. Level cannot be Serializable
+            because it is a flyweight.  Due to its special serialization it
+            cannot be declared final either.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Message">
+            <summary>
+            The application supplied message.
+            </summary>
+            <remarks>
+            <para>
+            The application supplied message of logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ThreadName">
+            <summary>
+            The name of thread
+            </summary>
+            <remarks>
+            <para>
+            The name of thread in which this logging event was generated
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.TimeStamp">
+            <summary>
+            Gets or sets the local time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            Prefer using the <see cref="P:log4net.Core.LoggingEventData.TimeStampUtc"/> setter, since local time can be ambiguous.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.LocationInfo">
+            <summary>
+            Location information for the caller.
+            </summary>
+            <remarks>
+            <para>
+            Location information for the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.UserName">
+            <summary>
+            String representation of the user
+            </summary>
+            <remarks>
+            <para>
+            String representation of the user's windows name,
+            like DOMAIN\username
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Identity">
+            <summary>
+            String representation of the identity.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the current thread's principal identity.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.ExceptionString">
+            <summary>
+            The string representation of the exception
+            </summary>
+            <remarks>
+            <para>
+            The string representation of the exception
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Domain">
+            <summary>
+            String representation of the AppDomain.
+            </summary>
+            <remarks>
+            <para>
+            String representation of the AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEventData.Properties">
+            <summary>
+            Additional event specific properties
+            </summary>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEventData.TimeStampUtc">
+            <summary>
+            Gets or sets the UTC time the event was logged
+            </summary>
+            <remarks>
+            <para>
+            The TimeStamp is stored in the UTC time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.FixFlags">
+            <summary>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </summary>
+            <remarks>
+            <para>
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Mdc">
+            <summary>
+            Fix the MDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Ndc">
+            <summary>
+            Fix the NDC
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Message">
+            <summary>
+            Fix the rendered message
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.ThreadName">
+            <summary>
+            Fix the thread name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.LocationInfo">
+            <summary>
+            Fix the callers location information
+            </summary>
+            <remarks>
+            CAUTION: Very slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.UserName">
+            <summary>
+            Fix the callers windows user name
+            </summary>
+            <remarks>
+            CAUTION: Slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Domain">
+            <summary>
+            Fix the domain friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Identity">
+            <summary>
+            Fix the callers principal name
+            </summary>
+            <remarks>
+            CAUTION: May be slow to generate
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Exception">
+            <summary>
+            Fix the exception text
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Properties">
+            <summary>
+            Fix the event properties. Active properties must implement <see cref="T:log4net.Core.IFixingRequired"/> in order to be eligible for fixing.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.None">
+            <summary>
+            No fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.All">
+            <summary>
+            All fields fixed
+            </summary>
+        </member>
+        <member name="F:log4net.Core.FixFlags.Partial">
+            <summary>
+            Partial fields fixed
+            </summary>
+            <remarks>
+            <para>
+            This set of partial fields gives good performance. The following fields are fixed:
+            </para>
+            <list type="bullet">
+            <item><description><see cref="F:log4net.Core.FixFlags.Message"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.ThreadName"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Exception"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Domain"/></description></item>
+            <item><description><see cref="F:log4net.Core.FixFlags.Properties"/></description></item>
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LoggingEvent">
+            <summary>
+            The internal representation of logging events. 
+            </summary>
+            <remarks>
+            <para>
+            When an affirmative decision is made to log then a 
+            <see cref="T:log4net.Core.LoggingEvent"/> instance is created. This instance 
+            is passed around to the different log4net components.
+            </para>
+            <para>
+            This class is of concern to those wishing to extend log4net.
+            </para>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.HostNameProperty">
+            <summary>
+            The key into the Properties map for the host name value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.IdentityProperty">
+            <summary>
+            The key into the Properties map for the thread identity value.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.UserNameProperty">
+            <summary>
+            The key into the Properties map for the user name value.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,System.String,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class
+            from the supplied parameters.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="loggerName">The name of the logger of this event.</param>
+            <param name="level">The level of this event.</param>
+            <param name="message">The message of this event.</param>
+            <param name="exception">The exception for this event.</param>
+            <remarks>
+            <para>
+            Except <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.Core.LoggingEvent.Level"/> and <see cref="P:log4net.Core.LoggingEvent.LoggerName"/>, 
+            all fields of <c>LoggingEvent</c> are filled when actually needed. Call
+            <see cref="M:FixVolatileData()"/> to cache all data locally
+            to prevent inconsistencies.
+            </para>
+            <para>This method is called by the log4net framework
+            to create a logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData,log4net.Core.FixFlags)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            The <paramref name="fixedData"/> parameter should be used to specify which fields in the
+            <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>
+            will be captured from the environment if requested or fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="repository">The repository this event is logged in.</param>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(log4net.Core.LoggingEventData)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            using specific data.
+            </summary>
+            <param name="data">Data used to initialize the logging event.</param>
+            <remarks>
+            <para>
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>
+            to be created independently of the log4net framework. This can
+            be useful if you require a custom serialization scheme.
+            </para>
+            <para>
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an 
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.
+            </para>
+            <para>
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
+            parameter and no other data should be captured from the environment.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.EnsureRepository(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Ensure that the repository is set.
+            </summary>
+            <param name="repository">the value for the repository</param>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)">
+            <summary>
+            Write the rendered message to a TextWriter
+            </summary>
+            <param name="writer">the writer to write the message to</param>
+            <remarks>
+            <para>
+            Unlike the <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property this method
+            does store the message data in the internal cache. Therefore 
+            if called only once this method should be faster than the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property, however if the message is
+            to be accessed multiple times then the property will be more efficient.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            The data in this event must be fixed before it can be serialized.
+            </para>
+            <para>
+            The <see cref="M:FixVolatileData()"/> method must be called during the
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method call if this event 
+            is to be used outside that method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            <para>
+            Does a <see cref="F:log4net.Core.FixFlags.Partial"/> fix of the data
+            in the logging event before returning the event data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData(log4net.Core.FixFlags)">
+            <summary>
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>
+            <remarks>
+            <para>
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionStrRep">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            <b>Obsolete. Use <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> instead.</b>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionString">
+            <summary>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <returns>
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </returns>
+            <remarks>
+            <para>
+            Returns this event's exception's rendered using the 
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData">
+            <summary>
+            Fix instance fields that hold volatile data.
+            </summary>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            Calling <see cref="M:FixVolatileData()"/> is equivalent to
+            calling <see cref="M:FixVolatileData(bool)"/> passing the parameter
+            <c>false</c>.
+            </para>
+            <para>
+            See <see cref="M:FixVolatileData(bool)"/> for more
+            information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)">
+            <summary>
+            Fixes instance fields that hold volatile data.
+            </summary>
+            <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>
+            <remarks>
+            <para>
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>
+            are considered volatile, that is the values are correct at the
+            time the event is delivered to appenders, but will not be consistent
+            at any time afterwards. If an event is to be stored and then processed
+            at a later time these volatile values must be fixed by calling
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it
+            is essential to maintaining data consistency.
+            </para>
+            <para>
+            The <paramref name="fastButLoose"/> param controls the data that
+            is fixed. Some of the data that can be fixed takes a long time to 
+            generate, therefore if you do not require those settings to be fixed
+            they can be ignored by setting the <paramref name="fastButLoose"/> param
+            to <c>true</c>. This setting will ignore the <see cref="P:log4net.Core.LoggingEvent.LocationInformation"/>
+            and <see cref="P:log4net.Core.LoggingEvent.UserName"/> settings.
+            </para>
+            <para>
+            Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all 
+            settings are fixed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)">
+            <summary>
+            Fix the fields specified by the <see cref="T:log4net.Core.FixFlags"/> parameter
+            </summary>
+            <param name="flags">the fields to fix</param>
+            <remarks>
+            <para>
+            Only fields specified in the <paramref name="flags"/> will be fixed.
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.LookupProperty(System.String)">
+            <summary>
+            Lookup a composite property in this event
+            </summary>
+            <param name="key">the key for the property to lookup</param>
+            <returns>the value for the property</returns>
+            <remarks>
+            <para>
+            This event has composite properties that combine together properties from
+            several different contexts in the following order:
+            <list type="definition">
+            	<item>
+            		<term>this events properties</term>
+            		<description>
+            		This event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            		properties are specific to this event only.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the thread properties</term>
+            		<description>
+            		The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            		thread. These properties are shared by all events logged on this thread.
+            		</description>
+            	</item>
+            	<item>
+            		<term>the global properties</term>
+            		<description>
+            		The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            		properties are shared by all the threads in the AppDomain.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LoggingEvent.GetProperties">
+            <summary>
+            Get all the composite properties in this event
+            </summary>
+            <returns>the <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the properties</returns>
+            <remarks>
+            <para>
+            See <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/> for details of the composite properties 
+            stored by the event.
+            </para>
+            <para>
+            This method returns a single <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the
+            properties defined for this event.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_data">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_compositeProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_eventProperties">
+            <summary>
+            The internal logging event data.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_callerStackBoundaryDeclaringType">
+            <summary>
+            The fully qualified Type of the calling 
+            logger class in the stack frame (i.e. the declaring type of the method).
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_message">
+            <summary>
+            The application supplied message of logging event.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_thrownException">
+            <summary>
+            The exception that was thrown.
+            </summary>
+            <remarks>
+            This is not serialized. The string representation
+            is serialized instead.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_repository">
+            <summary>
+            The repository that generated the logging event
+            </summary>
+            <remarks>
+            This is not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_fixFlags">
+            <summary>
+            The fix state for this event
+            </summary>
+            <remarks>
+            These flags indicate which fields have been fixed.
+            Not serialized.
+            </remarks>
+        </member>
+        <member name="F:log4net.Core.LoggingEvent.m_cacheUpdatable">
+            <summary>
+            Indicated that the internal cache is updateable (ie not fixed)
+            </summary>
+            <remarks>
+            This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler
+            changes in the caching strategy.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTime">
+            <summary>
+            Gets the time when the current process started.
+            </summary>
+            <value>
+            This is the time when this process started.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored internally in UTC and converted to the local time zone for this computer.
+            </para>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.StartTimeUtc">
+            <summary>
+            Gets the UTC time when the current process started.
+            </summary>
+            <value>
+            This is the UTC time when this process started.
+            </value>
+            <remarks>
+            <para>
+            Tries to get the start time for the current process.
+            Failing that it returns the time of the first call to
+            this property.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating and therefore
+            without the process start time being reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Level">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStamp">
+            <summary>
+            Gets the time of the logging event.
+            </summary>
+            <value>
+            The time of the logging event.
+            </value>
+            <remarks>
+            <para>
+            The TimeStamp is stored in UTC and converted to the local time zone for this computer.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.TimeStampUtc">
+            <summary>
+            Gets UTC the time of the logging event.
+            </summary>
+            <value>
+            The UTC time of the logging event.
+            </value>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LoggerName">
+            <summary>
+            Gets the name of the logger that logged the event.
+            </summary>
+            <value>
+            The name of the logger that logged the event.
+            </value>
+            <remarks>
+            <para>
+            Gets the name of the logger that logged the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.LocationInformation">
+            <summary>
+            Gets the location information for this logging event.
+            </summary>
+            <value>
+            The location information for this logging event.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Core.LocationInfo"/> class for more information on
+            supported frameworks and the different behavior in Debug and
+            Release builds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.MessageObject">
+            <summary>
+            Gets the message object used to initialize this event.
+            </summary>
+            <value>
+            The message object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the message object used to initialize this event.
+            Note that this event may not have a valid message object.
+            If the event is serialized the message object will not 
+            be transferred. To get the text of the message the
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined message object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ExceptionObject">
+            <summary>
+            Gets the exception object used to initialize this event.
+            </summary>
+            <value>
+            The exception object used to initialize this event.
+            </value>
+            <remarks>
+            <para>
+            Gets the exception object used to initialize this event.
+            Note that this event may not have a valid exception object.
+            If the event is serialized the exception object will not 
+            be transferred. To get the text of the exception the
+            <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> method must be used 
+            not this property.
+            </para>
+            <para>
+            If there is no defined exception object for this event then
+            null will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Repository">
+            <summary>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.RenderedMessage">
+            <summary>
+            Gets the message, rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </summary>
+            <value>
+            The message rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.ThreadName">
+            <summary>
+            Gets the name of the current thread.  
+            </summary>
+            <value>
+            The name of the current thread, or the thread ID when 
+            the name is not available.
+            </value>
+            <remarks>
+            <para>
+            The collected information is cached for future use.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.UserName">
+            <summary>
+            Gets the name of the current user.
+            </summary>
+            <value>
+            The name of the current user, or <c>NOT AVAILABLE</c> when the 
+            underlying runtime has no support for retrieving the name of the 
+            current user.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of
+            the current windows user.
+            </para>
+            <para>
+            To improve performance, we could cache the string representation of 
+            the name, and reuse that as long as the identity stayed constant.  
+            Once the identity changed, we would need to re-assign and re-render 
+            the string.
+            </para>
+            <para>
+            However, the <c>WindowsIdentity.GetCurrent()</c> call seems to 
+            return different objects every time, so the current implementation 
+            doesn't do this type of caching.
+            </para>
+            <para>
+            Timing for these operations:
+            </para>
+            <list type="table">
+              <listheader>
+                <term>Method</term>
+                <description>Results</description>
+              </listheader>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent()</c></term>
+                <description>10000 loops, 00:00:00.2031250 seconds</description>
+              </item>
+              <item>
+                <term><c>WindowsIdentity.GetCurrent().Name</c></term>
+                <description>10000 loops, 00:00:08.0468750 seconds</description>
+              </item>
+            </list>
+            <para>
+            This means we could speed things up almost 40 times by caching the 
+            value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since 
+            this takes (8.04-0.20) = 7.84375 seconds.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Identity">
+            <summary>
+            Gets the identity of the current thread principal.
+            </summary>
+            <value>
+            The string name of the identity of the current thread principal.
+            </value>
+            <remarks>
+            <para>
+            Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get
+            the name of the current thread principal.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Domain">
+            <summary>
+            Gets the AppDomain friendly name.
+            </summary>
+            <value>
+            The AppDomain friendly name.
+            </value>
+            <remarks>
+            <para>
+            Gets the AppDomain friendly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Properties">
+            <summary>
+            Additional event specific properties.
+            </summary>
+            <value>
+            Additional event specific properties.
+            </value>
+            <remarks>
+            <para>
+            A logger or an appender may attach additional
+            properties to specific events. These properties
+            have a string key and an object value.
+            </para>
+            <para>
+            This property is for events that have been added directly to
+            this event. The aggregate properties (which include these
+            event properties) can be retrieved using <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/>
+            and <see cref="M:log4net.Core.LoggingEvent.GetProperties"/>.
+            </para>
+            <para>
+            Once the properties have been fixed <see cref="P:log4net.Core.LoggingEvent.Fix"/> this property
+            returns the combined cached properties. This ensures that updates to
+            this property are always reflected in the underlying storage. When
+            returning the combined properties there may be more keys in the
+            Dictionary than expected.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LoggingEvent.Fix">
+            <summary>
+            The fixed fields in this event
+            </summary>
+            <value>
+            The set of fields that are fixed in this event
+            </value>
+            <remarks>
+            <para>
+            Fields will not be fixed if they have previously been fixed.
+            It is not possible to 'unfix' a field.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.LogImpl">
+            <summary>
+            Implementation of <see cref="T:log4net.ILog"/> wrapper interface.
+            </summary>
+            <remarks>
+            <para>
+            This implementation of the <see cref="T:log4net.ILog"/> interface
+            forwards to the <see cref="T:log4net.Core.ILogger"/> held by the base class.
+            </para>
+            <para>
+            This logger has methods to allow the caller to log at the following
+            levels:
+            </para>
+            <list type="definition">
+              <item>
+                <term>DEBUG</term>
+                <description>
+                The <see cref="M:Debug(object)"/> and <see cref="M:DebugFormat(string, object[])"/> methods log messages
+                at the <c>DEBUG</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Debug"/>. The <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>INFO</term>
+                <description>
+                The <see cref="M:Info(object)"/> and <see cref="M:InfoFormat(string, object[])"/> methods log messages
+                at the <c>INFO</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Info"/>. The <see cref="P:log4net.Core.LogImpl.IsInfoEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>WARN</term>
+                <description>
+                The <see cref="M:Warn(object)"/> and <see cref="M:WarnFormat(string, object[])"/> methods log messages
+                at the <c>WARN</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Warn"/>. The <see cref="P:log4net.Core.LogImpl.IsWarnEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>ERROR</term>
+                <description>
+                The <see cref="M:Error(object)"/> and <see cref="M:ErrorFormat(string, object[])"/> methods log messages
+                at the <c>ERROR</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Error"/>. The <see cref="P:log4net.Core.LogImpl.IsErrorEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+              <item>
+                <term>FATAL</term>
+                <description>
+                The <see cref="M:Fatal(object)"/> and <see cref="M:FatalFormat(string, object[])"/> methods log messages
+                at the <c>FATAL</c> level. That is the level with that name defined in the
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value
+                for this level is <see cref="F:log4net.Core.Level.Fatal"/>. The <see cref="P:log4net.Core.LogImpl.IsFatalEnabled"/>
+                property tests if this level is enabled for logging.
+                </description>
+              </item>
+            </list>
+            <para>
+            The values for these levels and their semantic meanings can be changed by 
+            configuring the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> for the repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ILog">
+            <summary>
+            The ILog interface is use by application to log messages into
+            the log4net framework.
+            </summary>
+            <remarks>
+            <para>
+            Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
+            that implement this interface. The <see cref="M:LogManager.GetLogger(Assembly,Type)"/>
+            static method is used to get logger instances.
+            </para>
+            <para>
+            This class contains methods for logging at different levels and also
+            has properties for determining if those logging levels are
+            enabled in the current configuration.
+            </para>
+            <para>
+            This interface can be implemented in different ways. This documentation
+            specifies reasonable behavior that a caller can expect from the actual
+            implementation, however different implementations reserve the right to
+            do things differently.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <seealso cref="T:log4net.LogManager"/>
+            <seealso cref="M:LogManager.GetLogger(Assembly, Type)"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">
+            <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+            <param name="message">The message object to log.</param>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object,Exception)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para> For some ILog interface <c>log</c>, when you write:</para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, string construction and concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed (who isn't), then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
+            the <see cref="M:Debug(object)"/>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log. This is the preferred style of logging.
+            </para>
+            <para>Alternatively if your logger is available statically then the is debug
+            enabled state can be stored in a static variable like this:
+            </para>
+            <code lang="C#">
+            private static readonly bool isDebugEnabled = log.IsDebugEnabled;
+            </code>
+            <para>
+            Then when you come to log you can write:
+            </para>
+            <code lang="C#">
+            if (isDebugEnabled)
+            { 
+                log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way the debug enabled state is only queried once
+            when the class is loaded. Using a <c>private static readonly</c>
+            variable is the most efficient because it is a run time constant
+            and can be heavily optimized by the JIT compiler.
+            </para>
+            <para>
+            Of course if you use a static readonly variable to
+            hold the enabled state of the logger then you cannot
+            change the enabled state at runtime to vary the logging
+            that is produced. You have to decide if you need absolute
+            speed or runtime flexibility.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+            <seealso cref="M:DebugFormat(IFormatProvider, string, object[])"/>
+        </member>
+        <member name="P:log4net.ILog.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+            <seealso cref="M:InfoFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+            <seealso cref="M:WarnFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+            <seealso cref="M:ErrorFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.ILog.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
+            </value>
+            <remarks>
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+            <seealso cref="M:FatalFormat(IFormatProvider, string, object[])"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.#ctor(log4net.Core.ILogger)">
+            <summary>
+            Construct a new wrapper for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <remarks>
+            <para>
+            Construct a new wrapper for the specified logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ReloadLevels(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Virtual method called when the configuration of the repository changes
+            </summary>
+            <param name="repository">the repository holding the levels</param>
+            <remarks>
+            <para>
+            Virtual method called when the configuration of the repository changes
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>DEBUG</c>
+            enabled by comparing the level of this logger with the 
+            <c>DEBUG</c> level. If this logger is
+            <c>DEBUG</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Debug(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>DEBUG</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>DEBUG</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> passed
+            as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Debug(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Debug(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>DEBUG</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by comparing the level of this logger with the 
+            <c>INFO</c> level. If this logger is
+            <c>INFO</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:Info(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Info(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>INFO</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>INFO</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Info(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Info(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>INFO</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level.
+            </summary>
+            <param name="message">the message object to log</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by comparing the level of this logger with the 
+            <c>WARN</c> level. If this logger is
+            <c>WARN</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Warn(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>WARN</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>WARN</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Warn(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Warn(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>WARN</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by comparing the level of this logger with the 
+            <c>ERROR</c> level. If this logger is
+            <c>ERROR</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Error(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Error(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>ERROR</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>ERROR</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Error(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Error(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>ERROR</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level.
+            </summary>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by comparing the level of this logger with the 
+            <c>FATAL</c> level. If this logger is
+            <c>FATAL</c> enabled, then it converts the message object
+            (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger and 
+            also higher in the hierarchy depending on the value of the 
+            additivity flag.
+            </para>
+            <para>
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
+            method will print the name of the <see cref="T:System.Exception"/> but no
+            stack trace. To print a stack trace use the 
+            <see cref="M:Fatal(object,Exception)"/> form instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object,System.Exception)">
+            <summary>
+            Logs a message object with the <c>FATAL</c> level
+            </summary>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Logs a message object with the <c>FATAL</c> level including
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> 
+            passed as a parameter.
+            </para>
+            <para>
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:Fatal(object)"/>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            format provider. To specify a localized provider use the
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <c>FATAL</c> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See
+            <c>String.Format</c> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>
+            methods instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.LogImpl.LoggerRepositoryConfigurationChanged(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for the <see cref="E:log4net.Repository.ILoggerRepository.ConfigurationChanged"/> event
+            </summary>
+            <param name="sender">the repository</param>
+            <param name="e">Empty</param>
+        </member>
+        <member name="F:log4net.Core.LogImpl.ThisDeclaringType">
+            <summary>
+            The fully qualified name of this declaring type not the type of any subclass.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsDebugEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>DEBUG</c>
+            level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>DEBUG</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            This function is intended to lessen the computational cost of
+            disabled log debug statements.
+            </para>
+            <para>
+            For some <c>log</c> Logger object, when you write:
+            </para>
+            <code lang="C#">
+            log.Debug("This is entry number: " + i );
+            </code>
+            <para>
+            You incur the cost constructing the message, concatenation in
+            this case, regardless of whether the message is logged or not.
+            </para>
+            <para>
+            If you are worried about speed, then you should write:
+            </para>
+            <code lang="C#">
+            if (log.IsDebugEnabled())
+            { 
+             log.Debug("This is entry number: " + i );
+            }
+            </code>
+            <para>
+            This way you will not incur the cost of parameter
+            construction if debugging is disabled for <c>log</c>. On
+            the other hand, if the <c>log</c> is debug enabled, you
+            will incur the cost of evaluating whether the logger is debug
+            enabled twice. Once in <c>IsDebugEnabled</c> and once in
+            the <c>Debug</c>.  This is an insignificant overhead
+            since evaluating a logger takes about 1% of the time it
+            takes to actually log.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsInfoEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>INFO</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>INFO</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsWarnEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>WARN</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>WARN</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples 
+            of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsErrorEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>ERROR</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>ERROR</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="P:log4net.Core.LogImpl.IsFatalEnabled">
+            <summary>
+            Checks if this logger is enabled for the <c>FATAL</c> level.
+            </summary>
+            <value>
+            <c>true</c> if this logger is enabled for <c>FATAL</c> events,
+            <c>false</c> otherwise.
+            </value>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.
+            </para>
+            </remarks>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="T:log4net.Core.MethodItem">
+            <summary>
+            provides method information without actually referencing a System.Reflection.MethodBase
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.MethodItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor">
+            <summary>
+            constructs a method item for an unknown method.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String)">
+            <summary>
+            constructs a method item from the name of the method.
+            </summary>
+            <param name="name"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String,System.String[])">
+            <summary>
+            constructs a method item from the name of the method and its parameters.
+            </summary>
+            <param name="name"></param>
+            <param name="parameters"></param>
+        </member>
+        <member name="M:log4net.Core.MethodItem.#ctor(System.Reflection.MethodBase)">
+            <summary>
+            constructs a method item from a method base by determining the method name and its parameters.
+            </summary>
+            <param name="methodBase"></param>
+        </member>
+        <member name="F:log4net.Core.MethodItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Name">
+            <summary>
+            Gets the method name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The method name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.MethodItem.Parameters">
+            <summary>
+            Gets the method parameters of the caller making
+            the logging request.
+            </summary>
+            <value>
+            The method parameters of the caller making
+            the logging request
+            </value>
+            <remarks>
+            <para>
+            Gets the method parameters of the caller making
+            the logging request.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContext">
+            <summary>
+            A SecurityContext used by log4net when interacting with protected resources
+            </summary>
+            <remarks>
+            <para>
+            A SecurityContext used by log4net when interacting with protected resources
+            for example with operating system services. This can be used to impersonate
+            a principal that has been granted privileges on the system resources.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Core.SecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns>An <see cref="T:System.IDisposable"/> instance that will
+            revoke the impersonation of this SecurityContext, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Impersonate this security context. Further calls on the current
+            thread should now be made in the security context provided
+            by this object. When the <see cref="T:System.IDisposable"/> result 
+            <see cref="M:System.IDisposable.Dispose"/> method is called the security
+            context of the thread should be reverted to the state it was in
+            before <see cref="M:log4net.Core.SecurityContext.Impersonate(System.Object)"/> was called.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.SecurityContextProvider">
+            <summary>
+            The <see cref="T:log4net.Core.SecurityContextProvider"/> providers default <see cref="T:log4net.Core.SecurityContext"/> instances.
+            </summary>
+            <remarks>
+            <para>
+            A configured component that interacts with potentially protected system
+            resources uses a <see cref="T:log4net.Core.SecurityContext"/> to provide the elevated
+            privileges required. If the <see cref="T:log4net.Core.SecurityContext"/> object has
+            been not been explicitly provided to the component then the component
+            will request one from this <see cref="T:log4net.Core.SecurityContextProvider"/>.
+            </para>
+            <para>
+            By default the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is
+            an instance of <see cref="T:log4net.Core.SecurityContextProvider"/> which returns only
+            <see cref="T:log4net.Util.NullSecurityContext"/> objects. This is a reasonable default
+            where the privileges required are not know by the system.
+            </para>
+            <para>
+            This default behavior can be overridden by subclassing the <see cref="T:log4net.Core.SecurityContextProvider"/>
+            and overriding the <see cref="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)"/> method to return
+            the desired <see cref="T:log4net.Core.SecurityContext"/> objects. The default provider
+            can be replaced by programmatically setting the value of the 
+            <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> property.
+            </para>
+            <para>
+            An alternative is to use the <c>log4net.Config.SecurityContextProviderAttribute</c>
+            This attribute can be applied to an assembly in the same way as the
+            <c>log4net.Config.XmlConfiguratorAttribute"</c>. The attribute takes
+            the type to use as the <see cref="T:log4net.Core.SecurityContextProvider"/> as an argument.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Core.SecurityContextProvider.s_defaultProvider">
+            <summary>
+            The default provider
+            </summary>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.#ctor">
+            <summary>
+            Protected default constructor to allow subclassing
+            </summary>
+            <remarks>
+            <para>
+            Protected default constructor to allow subclassing
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)">
+            <summary>
+            Create a SecurityContext for a consumer
+            </summary>
+            <param name="consumer">The consumer requesting the SecurityContext</param>
+            <returns>An impersonation context</returns>
+            <remarks>
+            <para>
+            The default implementation is to return a <see cref="T:log4net.Util.NullSecurityContext"/>.
+            </para>
+            <para>
+            Subclasses should override this method to provide their own
+            behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.SecurityContextProvider.DefaultProvider">
+            <summary>
+            Gets or sets the default SecurityContextProvider
+            </summary>
+            <value>
+            The default SecurityContextProvider
+            </value>
+            <remarks>
+            <para>
+            The default provider is used by configured components that
+            require a <see cref="T:log4net.Core.SecurityContext"/> and have not had one
+            given to them.
+            </para>
+            <para>
+            By default this is an instance of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that returns <see cref="T:log4net.Util.NullSecurityContext"/> objects.
+            </para>
+            <para>
+            The default provider can be set programmatically by setting
+            the value of this property to a sub class of <see cref="T:log4net.Core.SecurityContextProvider"/>
+            that has the desired behavior.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.StackFrameItem">
+            <summary>
+            provides stack frame information without actually referencing a System.Diagnostics.StackFrame
+            as that would require that the containing assembly is loaded.
+            </summary>
+            
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.NA">
+            <summary>
+            When location information is not available the constant
+            <c>NA</c> is returned. Current value of this string
+            constant is <b>?</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.StackFrameItem.#ctor(System.Diagnostics.StackFrame)">
+            <summary>
+            returns a stack frame item from a stack frame. This 
+            </summary>
+            <param name="frame"></param>
+            <returns></returns>
+        </member>
+        <member name="F:log4net.Core.StackFrameItem.declaringType">
+            <summary>
+            The fully qualified type of the StackFrameItem class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.ClassName">
+            <summary>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </summary>
+            <value>
+            The fully qualified class name of the caller making the logging 
+            request.
+            </value>
+            <remarks>
+            <para>
+            Gets the fully qualified class name of the caller making the logging 
+            request.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FileName">
+            <summary>
+            Gets the file name of the caller.
+            </summary>
+            <value>
+            The file name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the file name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.LineNumber">
+            <summary>
+            Gets the line number of the caller.
+            </summary>
+            <value>
+            The line number of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the line number of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.Method">
+            <summary>
+            Gets the method name of the caller.
+            </summary>
+            <value>
+            The method name of the caller.
+            </value>
+            <remarks>
+            <para>
+            Gets the method name of the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.StackFrameItem.FullInfo">
+            <summary>
+            Gets all available caller information
+            </summary>
+            <value>
+            All available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </value>
+            <remarks>
+            <para>
+            Gets all available caller information, in the format
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.TimeEvaluator">
+            <summary>
+            An evaluator that triggers after specified number of seconds.
+            </summary>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+            <author>Robert Sevcik</author>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL">
+            <summary>
+            The default time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_interval">
+            <summary>
+            The time threshold for triggering in seconds. Zero means it won't trigger at all.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.TimeEvaluator.m_lastTimeUtc">
+            <summary>
+            The UTC time of last check. This gets updated when the object is created and when the evaluator triggers.
+            </summary>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor">
+            <summary>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </summary>
+            <remarks>
+            <para>
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.#ctor(System.Int32)">
+            <summary>
+            Create a new evaluator using the specified time threshold in seconds.
+            </summary>
+            <param name="interval">
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </param>
+            <remarks>
+            <para>
+            Create a new evaluator using the specified time threshold in seconds.
+            </para>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.TimeEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
+            <summary>
+            Is this <paramref name="loggingEvent"/> the triggering event?
+            </summary>
+            <param name="loggingEvent">The event to check</param>
+            <returns>This method returns <c>true</c>, if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.. 
+            Otherwise it returns <c>false</c></returns>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Core.TimeEvaluator.Interval">
+            <summary>
+            The time threshold in seconds to trigger after
+            </summary>
+            <value>
+            The time threshold in seconds to trigger after.
+            Zero means it won't trigger at all.
+            </value>
+            <remarks>
+            <para>
+            This evaluator will trigger if the specified time period 
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperCreationHandler">
+            <summary>
+            Delegate used to handle creation of new wrappers.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <remarks>
+            <para>
+            Delegate used to handle creation of new wrappers. This delegate
+            is called from the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method to construct the wrapper for the specified logger.
+            </para>
+            <para>
+            The delegate to use is supplied to the <see cref="T:log4net.Core.WrapperMap"/>
+            constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Core.WrapperMap">
+            <summary>
+            Maps between logger objects and wrapper objects.
+            </summary>
+            <remarks>
+            <para>
+            This class maintains a mapping between <see cref="T:log4net.Core.ILogger"/> objects and
+            <see cref="T:log4net.Core.ILoggerWrapper"/> objects. Use the <see cref="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)"/> method to 
+            lookup the <see cref="T:log4net.Core.ILoggerWrapper"/> for the specified <see cref="T:log4net.Core.ILogger"/>.
+            </para>
+            <para>
+            New wrapper instances are created by the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>
+            method. The default behavior is for this method to delegate construction
+            of the wrapper to the <see cref="T:log4net.Core.WrapperCreationHandler"/> delegate supplied
+            to the constructor. This allows specialization of the behavior without
+            requiring subclassing of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.#ctor(log4net.Core.WrapperCreationHandler)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/>
+            </summary>
+            <param name="createWrapperHandler">The handler to use to create the wrapper objects.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/> class with 
+            the specified handler to create the wrapper objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)">
+            <summary>
+            Gets the wrapper object for the specified logger.
+            </summary>
+            <returns>The wrapper object for the specified logger</returns>
+            <remarks>
+            <para>
+            If the logger is null then the corresponding wrapper is null.
+            </para>
+            <para>
+            Looks up the wrapper it it has previously been requested and
+            returns it. If the wrapper has never been requested before then
+            the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/> virtual method is
+            called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)">
+            <summary>
+            Creates the wrapper object for the specified logger.
+            </summary>
+            <param name="logger">The logger to wrap in a wrapper.</param>
+            <returns>The wrapper object for the logger.</returns>
+            <remarks>
+            <para>
+            This implementation uses the <see cref="T:log4net.Core.WrapperCreationHandler"/>
+            passed to the constructor to create the wrapper. This method
+            can be overridden in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.RepositoryShutdown(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Called when a monitored repository shutdown event is received.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down</param>
+            <remarks>
+            <para>
+            This method is called when a <see cref="T:log4net.Repository.ILoggerRepository"/> that this
+            <see cref="T:log4net.Core.WrapperMap"/> is holding loggers for has signaled its shutdown
+            event <see cref="E:log4net.Repository.ILoggerRepository.ShutdownEvent"/>. The default
+            behavior of this method is to release the references to the loggers
+            and their wrappers generated for this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Core.WrapperMap.ILoggerRepository_Shutdown(System.Object,System.EventArgs)">
+            <summary>
+            Event handler for repository shutdown event.
+            </summary>
+            <param name="sender">The sender of the event.</param>
+            <param name="e">The event args.</param>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_repositories">
+            <summary>
+            Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_createWrapperHandler">
+            <summary>
+            The handler to use to create the extension wrapper objects.
+            </summary>
+        </member>
+        <member name="F:log4net.Core.WrapperMap.m_shutdownHandler">
+            <summary>
+            Internal reference to the delegate used to register for repository shutdown events.
+            </summary>
+        </member>
+        <member name="P:log4net.Core.WrapperMap.Repositories">
+            <summary>
+            Gets the map of logger repositories.
+            </summary>
+            <value>
+            Map of logger repositories.
+            </value>
+            <remarks>
+            <para>
+            Gets the hashtable that is keyed on <see cref="T:log4net.Repository.ILoggerRepository"/>. The
+            values are hashtables keyed on <see cref="T:log4net.Core.ILogger"/> with the
+            value being the corresponding <see cref="T:log4net.Core.ILoggerWrapper"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.DateFormatter.IDateFormatter">
+            <summary>
+            Render a <see cref="T:System.DateTime"/> as a string.
+            </summary>
+            <remarks>
+            <para>
+            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
+            instance into a string.
+            </para>
+            <para>
+            The <see cref="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/> method is used to render the
+            date to a text writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the specified date as a string.
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:System.DateTime"/> as a string and write it
+            to the <see cref="T:System.IO.TextWriter"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.AbsoluteTimeDateFormat">
+            <summary>
+            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DateAndTimeDateFormat">
+            <summary>
+            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.Iso8601TimeDateFormat">
+            <summary>
+            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.
+            </summary>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Renders the date into a string. Format is <c>"HH:mm:ss"</c>.
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to render the date
+            into a string using a precision up to the second. This method
+            will be called at most once per second and the result will be
+            reused if it is needed again during the same second.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Renders the date into a string. Format is "HH:mm:ss,fff".
+            </summary>
+            <param name="dateToFormat">The date to render into a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> method to generate the
+            time string up to the seconds and then appends the current
+            milliseconds. The results from <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> are
+            cached and <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> is called at most once
+            per second.
+            </para>
+            <para>
+            Sub classes should override <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/>
+            rather than <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeToTheSecond">
+            <summary>
+            Last stored time with precision up to the second.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeBuf">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeStrings">
+            <summary>
+            Last stored time with precision up to the second, formatted
+            as a string.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">
+            <summary>
+            Formats a <see cref="T:System.DateTime"/> as <c>"dd MMM yyyy HH:mm:ss,fff"</c>
+            </summary>
+            <remarks>
+            <para>
+            Formats a <see cref="T:System.DateTime"/> in the format 
+            <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, 
+            <c>"06 Nov 1994 15:49:37,459"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Angelika Schnagl</author>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">
+            <summary>
+            Default constructor.
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats a DateTime in the format <c>"dd MMM yyyy HH:mm:ss"</c>
+            for example, <c>"06 Nov 1994 15:49:37"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_dateTimeFormatInfo">
+            <summary>
+            The format info for the invariant culture.
+            </summary>
+        </member>
+        <member name="T:log4net.DateFormatter.Iso8601DateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> as <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> specified as a string: <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
+            <summary>
+            Formats the date without the milliseconds part
+            </summary>
+            <param name="dateToFormat">The date to format.</param>
+            <param name="buffer">The string builder to write to.</param>
+            <remarks>
+            <para>
+            Formats the date specified as a string: <c>"yyyy-MM-dd HH:mm:ss"</c>.
+            </para>
+            <para>
+            The base class will append the <c>",fff"</c> milliseconds section.
+            This method will only be called at most once per second.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.DateFormatter.SimpleDateFormatter">
+            <summary>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="T:System.DateTime"/> <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="format">The format string.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> class 
+            with the specified format string.
+            </para>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">
+            <summary>
+            Formats the date using <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </summary>
+            <param name="dateToFormat">The date to convert to a string.</param>
+            <param name="writer">The writer to write to.</param>
+            <remarks>
+            <para>
+            Uses the date format string supplied to the constructor to call
+            the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method to format the date.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">
+            <summary>
+            The format string used to format the <see cref="T:System.DateTime"/>.
+            </summary>
+            <remarks>
+            <para>
+            The format string must be compatible with the options
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.DenyAllFilter">
+            <summary>
+            This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>. 
+            </summary>
+            <remarks>
+            <para>
+            You can add this filter to the end of a filter chain to
+            switch from the default "accept all unless instructed otherwise"
+            filtering behavior to a "deny all unless instructed otherwise"
+            behavior.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.FilterSkeleton">
+            <summary>
+            Subclass this type to implement customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should extend this class to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.IFilter">
+            <summary>
+            Implement this interface to provide customized logging event filtering
+            </summary>
+            <remarks>
+            <para>
+            Users should implement this interface to implement customized logging
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and 
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
+            appenders, have built-in filtering rules. It is suggested that you
+            first use and understand the built-in rules before rushing to write
+            your own custom filters.
+            </para>
+            <para>
+            This abstract class assumes and also imposes that filters be
+            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            method of each filter is called sequentially, in the order of their 
+            addition to the chain.
+            </para>
+            <para>
+            The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, 
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped 
+            immediately without consulting with the remaining filters.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
+            in the chain is consulted. If there are no more filters in the
+            chain, then the log event is logged. Thus, in the presence of no
+            filters, the default behavior is to log all logging events.
+            </para>
+            <para>
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
+            event is logged without consulting the remaining filters.
+            </para>
+            <para>
+            The philosophy of log4net filters is largely inspired from the
+            Linux ipchains.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the logging event should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The LoggingEvent to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.IFilter.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterSkeleton.m_next">
+            <summary>
+            Points to the next filter in the filter chain.
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
+            <summary>
+            Initialize the filter with the options set
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Typically filter's options become active immediately on set, 
+            however this method must still be called. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.
+            </summary>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>
+            <returns>The decision of the filter</returns>
+            <remarks>
+            <para>
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
+            the event will be logged without consulting with other filters in
+            the chain.
+            </para>
+            <para>
+            This method is marked <c>abstract</c> and must be implemented
+            in a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.FilterSkeleton.Next">
+            <summary>
+            Property to get and set the next filter
+            </summary>
+            <value>
+            The next filter in the chain
+            </value>
+            <remarks>
+            <para>
+            Filters are typically composed into chains. This property allows the next filter in 
+            the chain to be accessed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            </summary>
+            <param name="loggingEvent">the LoggingEvent to filter</param>
+            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>
+            <remarks>
+            <para>
+            Ignores the event being logged and just returns
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter
+            chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter
+            should only be used as the last filter in the chain
+            as any further filters will be ignored!
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.FilterDecision">
+            <summary>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </summary>
+            <remarks>
+            <para>
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Deny">
+            <summary>
+            The log event must be dropped immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Neutral">
+            <summary>
+            This filter is neutral with respect to the log event. 
+            The remaining filters, if any, should be consulted for a final decision.
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.FilterDecision.Accept">
+            <summary>
+            The log event must be logged immediately without 
+            consulting with the remaining filters, if any, in the chain.
+            </summary>
+        </member>
+        <member name="T:log4net.Filter.LevelMatchFilter">
+            <summary>
+            This is a very simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and
+            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value
+            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.Core.Level"/> of the 
+            <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 
+            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set
+            to <c>true</c>, if it is <c>false</c> then 
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">
+            <summary>
+            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.Accept"/> on a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">
+            <summary>
+            the <see cref="T:log4net.Core.Level"/> to match against
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Tests if the <see cref="T:log4net.Core.Level"/> of the logging event matches that of the filter
+            </summary>
+            <param name="loggingEvent">the event to filter</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the event matches the level of the
+            filter then the result of the function depends on the
+            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then
+            the function will return <see cref="F:log4net.Filter.FilterDecision.Accept"/>, it it is false then it
+            will return <see cref="F:log4net.Filter.FilterDecision.Deny"/>. If the <see cref="T:log4net.Core.Level"/> does not match then
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">
+            <summary>
+            The <see cref="T:log4net.Core.Level"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            The level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LevelRangeFilter">
+            <summary>
+            This is a simple filter based on <see cref="T:log4net.Core.Level"/> matching.
+            </summary>
+            <remarks>
+            <para>
+            The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            that determine the range of priorities that are matched, and
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range
+            of priorities and the <see cref="T:log4net.Core.Level"/> of the <see cref="T:log4net.Core.LoggingEvent"/>, then the 
+            <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"/> 
+            option value is set to <c>true</c>, if it is <c>false</c>
+            then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when matching a <see cref="T:log4net.Core.Level"/>
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">
+            <summary>
+            the minimum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">
+            <summary>
+            the maximum <see cref="T:log4net.Core.Level"/> value to match
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if the event should be logged.
+            </summary>
+            <param name="loggingEvent">the logging event to check</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            If the <see cref="T:log4net.Core.Level"/> of the logging event is outside the range
+            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.Deny"/>
+            is returned. If the <see cref="T:log4net.Core.Level"/> is matched then the value of
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">
+            <summary>
+            Set the minimum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The minimum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">
+            <summary>
+            Sets the maximum matched <see cref="T:log4net.Core.Level"/>
+            </summary>
+            <remarks>
+            <para>
+            The maximum level that this filter will attempt to match against the 
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.LoggerMatchFilter">
+            <summary>
+            Simple filter to match a string in the event's logger name.
+            </summary>
+            <remarks>
+            <para>
+            The works very similar to the <see cref="T:log4net.Filter.LevelMatchFilter"/>. It admits two 
+            options <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> and <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>. If the 
+            <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <see cref="T:log4net.Core.LoggingEvent"/> starts 
+            with the value of the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> option, then the 
+            <see cref="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in 
+            case the <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> option value is set to <c>true</c>, 
+            if it is <c>false</c> then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_loggerToMatch">
+            <summary>
+            The logger name string to substring match against the event
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>.
+            If the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> equals the beginning of 
+            the incoming <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> (<see cref="M:String.StartsWith(string)"/>)
+            then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch">
+            <summary>
+            The <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> that the filter will match
+            </summary>
+            <remarks>
+            <para>
+            This filter will attempt to match this value against logger name in
+            the following way. The match will be done against the beginning of the
+            logger name (using <see cref="M:String.StartsWith(string)"/>). The match is
+            case sensitive. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.MdcFilter">
+            <summary>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with layered properties the
+            <see cref="T:log4net.Filter.PropertyFilter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Filter.PropertyFilter">
+            <summary>
+            Simple filter to match a string an event property
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the value for a
+            specific event property
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Filter.StringMatchFilter">
+            <summary>
+            Simple filter to match a string in the rendered message
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the rendered message
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">
+            <summary>
+            Flag to indicate the behavior when we have a match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">
+            <summary>
+            The string to substring match against the message
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">
+            <summary>
+            A string regex to match
+            </summary>
+        </member>
+        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">
+            <summary>
+            A regex object to match (generated from m_stringRegexToMatch)
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">
+            <summary>
+            Initialize and precompile the Regex if required
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The rendered message is matched against the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the message then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">
+            <summary>
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the 
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.
+            </para>
+            <para>
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">
+            <summary>
+            Sets the static string to match
+            </summary>
+            <remarks>
+            <para>
+            The string that will be substring matched against
+            the rendered message. If the message contains this
+            string then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">
+            <summary>
+            Sets the regular expression to match
+            </summary>
+            <remarks>
+            <para>
+            The regular expression pattern that will be matched against
+            the rendered message. If the message matches this
+            pattern then the filter will match. If a match is found then
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.
+            </para>
+            <para>
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>
+            must be specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Filter.PropertyFilter.m_key">
+            <summary>
+            The key to use to lookup the string from the event properties
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Filter.PropertyFilter.Decide(log4net.Core.LoggingEvent)">
+            <summary>
+            Check if this filter should allow the event to be logged
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>see remarks</returns>
+            <remarks>
+            <para>
+            The event property for the <see cref="P:log4net.Filter.PropertyFilter.Key"/> is matched against 
+            the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
+            the property value then a match will have occurred. If no match occurs
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>
+            allowing other filters to check the event. If a match occurs then
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Filter.PropertyFilter.Key">
+            <summary>
+            The key to lookup in the event properties and then match against.
+            </summary>
+            <remarks>
+            <para>
+            The key name to use to lookup in the properties map of the
+            <see cref="T:log4net.Core.LoggingEvent"/>. The match will be performed against 
+            the value of this property if it exists.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Filter.NdcFilter">
+            <summary>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </summary>
+            <remarks>
+            <para>
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
+            </para>
+            <para>
+            As the MDC has been replaced with named stacks stored in the
+            properties collections the <see cref="T:log4net.Filter.PropertyFilter"/> should 
+            be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Filter.NdcFilter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Sets the <see cref="P:log4net.Filter.PropertyFilter.Key"/> to <c>"NDC"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AppDomainPatternConverter">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Util.PatternConverter">
+            <summary>
+            Abstract class that provides the formatting functionality that 
+            derived classes need.
+            </summary>
+            <remarks>
+            <para>
+            Conversion specifiers in a conversion patterns are parsed to
+            individual PatternConverters. Each of which is responsible for
+            converting a logging event in a converter specific manner.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferSize">
+            <summary>
+            Initial buffer size
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferMaxCapacity">
+            <summary>
+            Maximum buffer size before it is recycled
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.#ctor">
+            <summary>
+            Protected constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternConverter"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Evaluate this pattern converter and write the output to a writer.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the appropriate way.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next pattern converter in the chains
+            </summary>
+            <param name="patternConverter">the pattern converter that should follow this converter in the chain</param>
+            <returns>the next converter</returns>
+            <remarks>
+            <para>
+            The PatternConverter can merge with its neighbor during this method (or a sub class).
+            Therefore the return value may or may not be the value of the argument passed in.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the pattern converter to the writer with appropriate formatting
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+            <remarks>
+            <para>
+            This method calls <see cref="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)"/> to allow the subclass to perform
+            appropriate conversion of the pattern converter. If formatting options have
+            been specified via the <see cref="P:log4net.Util.PatternConverter.FormattingInfo"/> then this method will
+            apply those formattings before writing the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.SpacePad(System.IO.TextWriter,System.Int32)">
+            <summary>
+            Fast space padding method.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> to which the spaces will be appended.</param>
+            <param name="length">The number of spaces to be padded.</param>
+            <remarks>
+            <para>
+            Fast space padding method.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternConverter.m_option">
+            <summary>
+            The option string to the converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionary)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionary"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionaryEnumerator)">
+            <summary>
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the <see cref="T:System.Collections.IDictionaryEnumerator"/> to a writer in the form:
+            </para>
+            <code>
+            {key1=value1, key2=value2, key3=value3}
+            </code>
+            <para>
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the key and value to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternConverter.WriteObject(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Object)">
+            <summary>
+            Write an object to a <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>
+            <param name="value">the value to write to the writer</param>
+            <remarks>
+            <para>
+            Writes the Object to a writer. If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified
+            is not null then it is used to render the object to text, otherwise
+            the object's ToString method is called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Next">
+            <summary>
+            Get the next pattern converter in the chain
+            </summary>
+            <value>
+            the next pattern converter in the chain
+            </value>
+            <remarks>
+            <para>
+            Get the next pattern converter in the chain
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.FormattingInfo">
+            <summary>
+            Gets or sets the formatting info for this converter
+            </summary>
+            <value>
+            The formatting info for this converter
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the formatting info for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Option">
+            <summary>
+            Gets or sets the option value for this converter
+            </summary>
+            <summary>
+            The option for this converter
+            </summary>
+            <remarks>
+            <para>
+            Gets or sets the option value for this converter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternConverter.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">The state object on which the pattern converter should be executed.</param>
+        </member>
+        <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">
+            <summary>
+            Flag indicating if this converter handles exceptions
+            </summary>
+            <remarks>
+            <c>false</c> if this converter handles exceptions
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">
+            <summary>
+            Flag indicating if this converter handles the logging event exception
+            </summary>
+            <value><c>false</c> if this converter handles the logging event exception</value>
+            <remarks>
+            <para>
+            If this converter handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the property should be set to <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this converter does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AppDomainPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event appdomain name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetCachePatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetPatternLayoutConverter">
+            <summary>
+            Abstract class that provides access to the current HttpContext (<see cref="P:System.Web.HttpContext.Current"/>) that 
+            derived classes need.
+            </summary>
+            <remarks>
+            This class handles the case when HttpContext.Current is null by writing
+            <see cref="P:log4net.Util.SystemInfo.NotAvailableText"/> to the writer.
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetPatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Derived pattern converters must override this method in order to
+            convert conversion specifiers in the correct way.
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetCachePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Cache will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetContextPatternConverter">
+            <summary>
+            Converter for items in the <see cref="T:System.Web.HttpContext"/>.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="T:System.Web.HttpContext"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetContextPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net HttpContext item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetRequestPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetRequestPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.AspNetSessionPatternConverter">
+            <summary>
+            Converter for items in the ASP.Net Cache.
+            </summary>
+            <remarks>
+            <para>
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.AspNetSessionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">
+            <summary>
+            Write the ASP.Net Cache item to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property. If no property has been set, all key value pairs from the Session will
+            be written to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.DatePatternConverter">
+            <summary>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </summary>
+            <remarks>
+            <para>
+            Render the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,yyyy"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Layout.Pattern.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter pattern based on the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ExceptionPatternConverter">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the exception text to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            If an exception object is stored in the logging event
+            it will be rendered into the pattern output with a
+            trailing newline.
+            </para>
+            <para>
+            If there is no exception or the exception property specified
+            by the Option value does not exist then nothing will be output
+            and no trailing newline will be appended.
+            It is typical to put a newline before the exception
+            and to have the exception as the last data in the pattern.
+            </para>
+            <para>
+            Recognized values for the Option parameter are:
+            </para>
+            <list type="bullet">
+            	<item>
+            		<description>Message</description>
+            	</item>
+            	<item>
+            		<description>Source</description>
+            	</item>
+            	<item>
+            		<description>StackTrace</description>
+            	</item>
+            	<item>
+            		<description>TargetSite</description>
+            	</item>
+            	<item>
+            		<description>HelpLink</description>
+            	</item>		
+            </list>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FileLocationPatternConverter">
+            <summary>
+            Writes the caller location file name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FileLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location file name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.FullLocationPatternConverter">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.FullLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location info to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.IdentityPatternConverter">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output writer.
+            </para>
+            </remarks>
+            <author>Daniel Cazzulino</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.IdentityPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event identity to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <paramref name="loggingEvent"/> 
+            <see cref="P:log4net.Core.LoggingEvent.Identity"/> to
+            the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LevelPatternConverter">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event level to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>
+            to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LineLocationPatternConverter">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the event to the output writer.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LineLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the caller location line number to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.LoggerPatternConverter">
+            <summary>
+            Converter for logger name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NamedPatternConverter">
+            <summary>
+            Converter to output and truncate <c>'.'</c> separated strings
+            </summary>
+            <remarks>
+            <para>
+            This abstract class supports truncating a <c>'.'</c> separated string
+            to show a specified number of elements from the right hand side.
+            This is used to truncate class names that are fully qualified.
+            </para>
+            <para>
+            Subclasses should override the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> method to
+            return the fully qualified string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter 
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Get the fully qualified string data
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>the fully qualified name</returns>
+            <remarks>
+            <para>
+            Overridden by subclasses to get the fully qualified name before the
+            precision is applied to it.
+            </para>
+            <para>
+            Return the fully qualified <c>'.'</c> (dot/period) separated string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> to the precision
+            specified by the <see cref="P:log4net.Util.PatternConverter.Option"/> property.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.NamedPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the NamedPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.LoggerPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the logger
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified logger name</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MessagePatternConverter">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Writes the event message to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
+            to write out the event message.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.MethodLocationPatternConverter">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.MethodLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the method name to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to
+            the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.NdcPatternConverter">
+            <summary>
+            Converter to include event NDC
+            </summary>
+            <remarks>
+            <para>
+            Outputs the value of the event property named <c>NDC</c>.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.NdcPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the event NDC to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            As the thread context stacks are now stored in named event properties
+            this converter simply looks up the value of the <c>NDC</c> property.
+            </para>
+            <para>
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.PropertyPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">
+            <summary>
+            Converter to output the relative time of the event
+            </summary>
+            <remarks>
+            <para>
+            Converter to output the time of the event relative to the start of the program.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the relative time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes out the relative time of the event in milliseconds.
+            That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>
+            and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
+            <summary>
+            Helper method to get the time difference between two DateTime objects
+            </summary>
+            <param name="start">start time (in the current local time zone)</param>
+            <param name="end">end time (in the current local time zone)</param>
+            <returns>the time difference in milliseconds</returns>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTraceDetailPatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            </para>
+            </remarks>
+            <author>Adam Davies</author>
+        </member>
+        <member name="T:log4net.Layout.Pattern.StackTracePatternConverter">
+            <summary>
+            Write the caller stack frames to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:
+            type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            </para>
+            </remarks>
+            <author>Michael Cromwell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the strack frames to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.GetMethodInformation(log4net.Core.MethodItem)">
+            <summary>
+            Returns the Name of the method
+            </summary>
+            <param name="method"></param>
+            <remarks>This method was created, so this class could be used as a base class for StackTraceDetailPatternConverter</remarks>
+            <returns>string</returns>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTracePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTracePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.Pattern.StackTraceDetailPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the StackTraceDetailPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.ThreadPatternConverter">
+            <summary>
+            Converter to include event thread name
+            </summary>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.ThreadPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the ThreadName to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.TypeNamePatternConverter">
+            <summary>
+            Pattern converter for the class name
+            </summary>
+            <remarks>
+            <para>
+            Outputs the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the event.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.TypeNamePatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the fully qualified name of the class
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <returns>The fully qualified type name for the caller location</returns>
+            <remarks>
+            <para>
+            Returns the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UserNamePatternConverter">
+            <summary>
+            Converter to include event user name
+            </summary>
+            <author>Douglas de la Torre</author>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UserNamePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Convert the pattern to the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+        </member>
+        <member name="T:log4net.Layout.Pattern.UtcDatePatternConverter">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            <para>
+            Uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> 
+            in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.Pattern.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.Pattern.UtcDatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Write the TimeStamp to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted
+            to Universal time before it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Layout.Pattern.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.DynamicPatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string that re-evaluates on each call.
+            </summary>
+            <remarks>
+            <para>This class is built on <see cref="T:log4net.Layout.PatternLayout"></see> and provides all the
+            features and capabilities of PatternLayout.  PatternLayout is a 'static' class
+            in that its layout is done once at configuration time.  This class will recreate
+            the layout on each reference.</para>
+            <para>One important difference between PatternLayout and DynamicPatternLayout is the
+            treatment of the Header and Footer parameters in the configuration.  The Header and Footer
+            parameters for DynamicPatternLayout must be syntactically in the form of a PatternString,
+            but should not be marked as type log4net.Util.PatternString.  Doing so causes the
+            pattern to be statically converted at configuration time and causes DynamicPatternLayout
+            to perform the same as PatternLayout.</para>
+            <para>Please see <see cref="T:log4net.Layout.PatternLayout"/> for complete documentation.</para>
+            <example>
+            &lt;layout type="log4net.Layout.DynamicPatternLayout"&gt;
+              &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;
+              &lt;param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;
+            &lt;/layout&gt;
+            </example>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.PatternLayout">
+            <summary>
+            A flexible layout configurable with pattern string.
+            </summary>
+            <remarks>
+            <para>
+            The goal of this class is to <see cref="M:PatternLayout.Format(TextWriter,LoggingEvent)"/> a 
+            <see cref="T:log4net.Core.LoggingEvent"/> as a string. The results
+            depend on the <i>conversion pattern</i>.
+            </para>
+            <para>
+            The conversion pattern is closely related to the conversion
+            pattern of the printf function in C. A conversion pattern is
+            composed of literal text and format control expressions called
+            <i>conversion specifiers</i>.
+            </para>
+            <para>
+            <i>You are free to insert any literal text within the conversion
+            pattern.</i>
+            </para>
+            <para>
+            Each conversion specifier starts with a percent sign (%) and is
+            followed by optional <i>format modifiers</i> and a <i>conversion
+            pattern name</i>. The conversion pattern name specifies the type of
+            data, e.g. logger, level, date, thread name. The format
+            modifiers control such things as field width, padding, left and
+            right justification. The following is a simple example.
+            </para>
+            <para>
+            Let the conversion pattern be <b>"%-5level [%thread]: %message%newline"</b> and assume
+            that the log4net environment was set to use a PatternLayout. Then the
+            statements
+            </para>
+            <code lang="C#">
+            ILog log = LogManager.GetLogger(typeof(TestApp));
+            log.Debug("Message 1");
+            log.Warn("Message 2");   
+            </code>
+            <para>would yield the output</para>
+            <code>
+            DEBUG [main]: Message 1
+            WARN  [main]: Message 2  
+            </code>
+            <para>
+            Note that there is no explicit separator between text and
+            conversion specifiers. The pattern parser knows when it has reached
+            the end of a conversion specifier when it reads a conversion
+            character. In the example above the conversion specifier
+            <b>%-5level</b> means the level of the logging event should be left
+            justified to a width of five characters.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>a</term>
+                    <description>Equivalent to <b>appdomain</b></description>
+                </item>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+            			Used to output the friendly name of the AppDomain where the 
+            			logging event was generated. 
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-cache</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-context</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-request</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>aspnet-session</term>
+                    <description>
+                        <para>
+                        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>
+                        </para>
+                        <para>
+                        This pattern is not available for Compact Framework or Client Profile assemblies.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>c</term>
+                    <description>Equivalent to <b>logger</b></description>
+                </item>
+                <item>
+                    <term>C</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>class</term>
+                    <description>Equivalent to <b>type</b></description>
+                </item>
+                <item>
+                    <term>d</term>
+                    <description>Equivalent to <b>date</b></description>
+                </item>
+                <item>
+            		<term>date</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>exception</term>
+            		<description>
+            			<para>
+            			Used to output the exception passed in with the log message.
+            			</para>
+            			<para>
+            			If an exception object is stored in the logging event
+            			it will be rendered into the pattern output with a
+            			trailing newline.
+            			If there is no exception then nothing will be output
+            			and no trailing newline will be appended.
+            			It is typical to put a newline before the exception
+            			and to have the exception as the last data in the pattern.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>F</term>
+                    <description>Equivalent to <b>file</b></description>
+                </item>
+            	<item>
+            		<term>file</term>
+            		<description>
+            			<para>
+            			Used to output the file name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>identity</term>
+            		<description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>l</term>
+                    <description>Equivalent to <b>location</b></description>
+                </item>
+                <item>
+                    <term>L</term>
+                    <description>Equivalent to <b>line</b></description>
+                </item>
+            	<item>
+            		<term>location</term>
+            		<description>
+            			<para>
+            			Used to output location information of the caller which generated
+            			the logging event.
+            			</para>
+            			<para>
+            			The location information depends on the CLI implementation but
+            			usually consists of the fully qualified name of the calling
+            			method followed by the callers source the file name and line
+            			number between parentheses.
+            			</para>
+            			<para>
+            			The location information can be very useful. However, its
+            			generation is <b>extremely</b> slow. Its use should be avoided
+            			unless execution speed is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>level</term>
+            		<description>
+            			<para>
+            			Used to output the level of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>line</term>
+            		<description>
+            			<para>
+            			Used to output the line number from where the logging request
+            			was issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>logger</term>
+                    <description>
+                        <para>
+            			Used to output the logger of the logging event. The
+            			logger conversion specifier can be optionally followed by
+            			<i>precision specifier</i>, that is a decimal constant in
+            			brackets.
+                        </para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the logger name will be
+            			printed. By default the logger name is printed in full.
+            			</para>
+            			<para>
+            			For example, for the logger name "a.b.c" the pattern
+            			<b>%logger{2}</b> will output "b.c".
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>m</term>
+                    <description>Equivalent to <b>message</b></description>
+                </item>
+                <item>
+                    <term>M</term>
+                    <description>Equivalent to <b>method</b></description>
+                </item>
+            	<item>
+            		<term>message</term>
+            		<description>
+            			<para>
+            			Used to output the application supplied message associated with 
+            			the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>mdc</term>
+            		<description>
+            			<para>
+            			The MDC (old name for the ThreadContext.Properties) is now part of the
+            			combined event properties. This pattern is supported for compatibility
+            			but is equivalent to <b>property</b>.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>method</term>
+            		<description>
+            			<para>
+            			Used to output the method name where the logging request was
+            			issued.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller location information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>n</term>
+                    <description>Equivalent to <b>newline</b></description>
+                </item>
+            	<item>
+            		<term>newline</term>
+            		<description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+            		</description>
+            	</item>
+            	<item>
+            		<term>ndc</term>
+            		<description>
+            			<para>
+            			Used to output the NDC (nested diagnostic context) associated
+            			with the thread that generated the logging event.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>p</term>
+                    <description>Equivalent to <b>level</b></description>
+                </item>
+                <item>
+                    <term>P</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+                <item>
+                    <term>properties</term>
+                    <description>Equivalent to <b>property</b></description>
+                </item>
+            	<item>
+            		<term>property</term>
+            		<description>
+            			<para>
+            			Used to output the an event specific property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are added to events by loggers or appenders. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the event properties</term>
+            					<description>
+            					The event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These 
+            					properties are specific to this event only.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+            			
+            		</description>
+            	</item>
+                <item>
+                    <term>r</term>
+                    <description>Equivalent to <b>timestamp</b></description>
+                </item>
+            	<item>
+            		<term>stacktrace</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktrace{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+            			type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>stacktracedetail</term> 
+            		<description>
+            			<para>
+            			Used to output the stack trace of the logging event
+            			The stack trace level specifier may be enclosed 
+            			between braces. For example, <b>%stacktracedetail{level}</b>.  
+            			If no stack trace level specifier is given then 1 is assumed 
+            			</para>
+            			<para>
+            			Output uses the format:
+                        type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)
+            			</para>
+                        <para>
+                        This pattern is not available for Compact Framework assemblies.
+                        </para>
+            		</description>
+            	</item>
+                <item>
+                    <term>t</term>
+                    <description>Equivalent to <b>thread</b></description>
+                </item>
+            	<item>
+            		<term>timestamp</term>
+            		<description>
+            			<para>
+            			Used to output the number of milliseconds elapsed since the start
+            			of the application until the creation of the logging event.
+            			</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term>thread</term>
+            		<description>
+            			<para>
+            			Used to output the name of the thread that generated the
+            			logging event. Uses the thread number if no name is available.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>type</term> 
+            		<description>
+            			<para>
+            			Used to output the fully qualified type name of the caller
+            			issuing the logging request. This conversion specifier
+            			can be optionally followed by <i>precision specifier</i>, that
+            			is a decimal constant in brackets.
+            			</para>
+            			<para>
+            			If a precision specifier is given, then only the corresponding
+            			number of right most components of the class name will be
+            			printed. By default the class name is output in fully qualified form.
+            			</para>
+            			<para>
+            			For example, for the class name "log4net.Layout.PatternLayout", the
+            			pattern <b>%type{1}</b> will output "PatternLayout".
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating the caller class information is
+            			slow. Thus, its use should be avoided unless execution speed is
+            			not an issue.
+            			</para>
+            			<para>
+            			See the note below on the availability of caller location information.
+            			</para>
+            		</description>
+                </item>
+                <item>
+                    <term>u</term>
+                    <description>Equivalent to <b>identity</b></description>
+                </item>
+            	<item>
+            		<term>username</term>
+            		<description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+            			<para>
+            			<b>WARNING</b> Generating caller WindowsIdentity information is
+            			extremely slow. Its use should be avoided unless execution speed
+            			is not an issue.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+            		<term>utcdate</term> 
+            		<description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            		</description>
+            	</item>
+                <item>
+                    <term>w</term>
+                    <description>Equivalent to <b>username</b></description>
+                </item>
+                <item>
+                    <term>x</term>
+                    <description>Equivalent to <b>ndc</b></description>
+                </item>
+                <item>
+                    <term>X</term>
+                    <description>Equivalent to <b>mdc</b></description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            The single letter patterns are deprecated in favor of the 
+            longer more descriptive pattern names.
+            </para>
+            <para>
+            By default the relevant information is output as is. However,
+            with the aid of format modifiers it is possible to change the
+            minimum field width, the maximum field width and justification.
+            </para>
+            <para>
+            The optional format modifier is placed between the percent sign
+            and the conversion pattern name.
+            </para>
+            <para>
+            The first optional format modifier is the <i>left justification
+            flag</i> which is just the minus (-) character. Then comes the
+            optional <i>minimum field width</i> modifier. This is a decimal
+            constant that represents the minimum number of characters to
+            output. If the data item requires fewer characters, it is padded on
+            either the left or the right until the minimum width is
+            reached. The default is to pad on the left (right justify) but you
+            can specify right padding with the left justification flag. The
+            padding character is space. If the data item is larger than the
+            minimum field width, the field is expanded to accommodate the
+            data. The value is never truncated.
+            </para>
+            <para>
+            This behavior can be changed using the <i>maximum field
+            width</i> modifier which is designated by a period followed by a
+            decimal constant. If the data item is longer than the maximum
+            field, then the extra characters are removed from the
+            <i>beginning</i> of the data item and not from the end. For
+            example, it the maximum field width is eight and the data item is
+            ten characters long, then the first two characters of the data item
+            are dropped. This behavior deviates from the printf function in C
+            where truncation is done from the end.
+            </para>
+            <para>
+            Below are various format modifier examples for the logger
+            conversion specifier.
+            </para>
+            <div class="tablediv">
+            	<table class="dtTABLE" cellspacing="0">
+            		<tr>
+            			<th>Format modifier</th>
+            			<th>left justify</th>
+            			<th>minimum width</th>
+            			<th>maximum width</th>
+            			<th>comment</th>
+            		</tr>
+            		<tr>
+            			<td align="center">%20logger</td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is less than 20
+            				characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">none</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger 
+            				name is less than 20 characters long.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%.30logger</td>
+            			<td align="center">NA</td>
+            			<td align="center">none</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Truncate from the beginning if the logger 
+            				name is longer than 30 characters.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center"><nobr>%20.30logger</nobr></td>
+            			<td align="center">false</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Left pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            		<tr>
+            			<td align="center">%-20.30logger</td>
+            			<td align="center">true</td>
+            			<td align="center">20</td>
+            			<td align="center">30</td>
+            			<td>
+            				<para>
+            				Right pad with spaces if the logger name is shorter than 20
+            				characters. However, if logger name is longer than 30 characters,
+            				then truncate from the beginning.
+            				</para>
+            			</td>
+            		</tr>
+            	</table>
+            </div>
+            <para>
+            <b>Note about caller location information.</b><br/>
+            The following patterns <c>%type %file %line %method %location %class %C %F %L %l %M</c> 
+            all generate caller location information.
+            Location information uses the <c>System.Diagnostics.StackTrace</c> class to generate
+            a call stack. The caller's information is then extracted from this stack.
+            </para>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the 
+            .NET Compact Framework 1.0 therefore caller location information is not
+            available on that framework.
+            </para>
+            </note>
+            <note type="caution">
+            <para>
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:
+            </para>
+            <para>
+            "StackTrace information will be most informative with Debug build configurations. 
+            By default, Debug builds include debug symbols, while Release builds do not. The 
+            debug symbols contain most of the file, method name, line number, and column 
+            information used in constructing StackFrame and StackTrace objects. StackTrace 
+            might not report as many method calls as expected, due to code transformations 
+            that occur during optimization."
+            </para>
+            <para>
+            This means that in a Release build the caller information may be incomplete or may 
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.
+            </para>
+            </note>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Layout.PatternLayout"/>
+            instance using the <see cref="M:AddConverter(string, Type)"/> method.
+            </para>
+            </remarks>
+            <example>
+            This is a more detailed pattern.
+            <code><b>%timestamp [%thread] %level %logger %ndc - %message%newline</b></code>
+            </example>
+            <example>
+            A similar pattern except that the relative time is
+            right padded if less than 6 digits, thread name is right padded if
+            less than 15 characters and truncated if longer and the logger
+            name is left padded if shorter than 30 characters and truncated if
+            longer.
+            <code><b>%-6timestamp [%15.15thread] %-5level %30.30logger %ndc - %message%newline</b></code>
+            </example>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Douglas de la Torre</author>
+            <author>Daniel Cazzulino</author>
+        </member>
+        <member name="T:log4net.Layout.LayoutSkeleton">
+            <summary>
+            Extend this abstract class to create your own log layout format.
+            </summary>
+            <remarks>
+            <para>
+            This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
+            interface. Most layout objects should extend this class.
+            </para>
+            </remarks>
+            <remarks>
+            <note type="inheritinfo">
+            <para>
+            Subclasses must implement the <see cref="M:Format(TextWriter,LoggingEvent)"/>
+            method.
+            </para>
+            <para>
+            Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default
+            constructor.
+            </para>
+            </note>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.ILayout">
+            <summary>
+            Interface implemented by layout objects
+            </summary>
+            <remarks>
+            <para>
+            An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            as text. The <see cref="M:Format(TextWriter,LoggingEvent)"/> method is called by an
+            appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.
+            </para>
+            <para>
+            The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
+            text that is appender before any events and after all the events respectively.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text and output to a writer.
+            </para>
+            <para>
+            If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the
+            event to be formatted as a <see cref="T:System.String"/> then the following
+            code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.
+            </para>
+            <code lang="C#">
+            StringWriter writer = new StringWriter();
+            Layout.Format(writer, loggingEvent);
+            string formattedEvent = writer.ToString();
+            </code>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type</value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This is a MIME type e.g. <c>"text/plain"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.ILayout.IgnoresException">
+            <summary>
+            Flag indicating if this layout handle exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_header">
+            <summary>
+            The header text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
+            <summary>
+            The footer text
+            </summary>
+            <remarks>
+            <para>
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <remarks>
+            <para>
+            <c>false</c> if this layout handles exceptions
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
+            <summary>
+            Empty default constructor
+            </summary>
+            <remarks>
+            <para>
+            Empty default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            This method must be implemented by the subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">The event to format</param>
+            <remarks>
+            <para>
+            This method is called by an appender to format
+            the <paramref name="loggingEvent"/> as text.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Convenience method for easily formatting the logging event into a string variable.
+            </summary>
+            <param name="loggingEvent"></param>
+            <remarks>
+            Creates a new StringWriter instance to store the formatted logging event.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
+            <summary>
+            The content type output by this layout. 
+            </summary>
+            <value>The content type is <c>"text/plain"</c></value>
+            <remarks>
+            <para>
+            The content type output by this layout.
+            </para>
+            <para>
+            This base class uses the value <c>"text/plain"</c>.
+            To change this value a subclass must override this
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
+            <summary>
+            Flag indicating if this layout handles exceptions
+            </summary>
+            <value><c>false</c> if this layout handles exceptions</value>
+            <remarks>
+            <para>
+            If this layout handles the exception object contained within
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
+            <c>false</c>. Otherwise, if the layout ignores the exception
+            object, then the layout should return <c>true</c>.
+            </para>
+            <para>
+            Set this value to override a this default setting. The default
+            value is <c>true</c>, this layout does not handle the exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DefaultConversionPattern">
+            <summary>
+            Default pattern string for log output. 
+            </summary>
+            <remarks>
+            <para>
+            Default pattern string for log output. 
+            Currently set to the string <b>"%message%newline"</b> 
+            which just prints the application supplied message. 
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.DetailConversionPattern">
+            <summary>
+            A detailed conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            A conversion pattern which includes Time, Thread, Logger, and Nested Context.
+            Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+            <remarks>
+            <para>
+            This static map is overridden by the m_converterRegistry instance map
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.PatternLayout.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternLayout only
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+            <remarks>
+            <para>
+            Defines the builtin global rules.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor">
+            <summary>
+            Constructs a PatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            As per the <see cref="T:log4net.Core.IOptionHandler"/> contract the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>
+            method must be called after the properties on this object have been
+            configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a PatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            <para>
+            Note to Inheritors: This constructor calls the virtual method
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be
+            aware that it will be called before your is called constructor.
+            </para>
+            <para>
+            When using this constructor the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method 
+            need not be called. This may not be the case when using a subclass.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">
+            <summary>
+            Create the pattern parser instance
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/> that will format the event</returns>
+            <remarks>
+            <para>
+            Creates the <see cref="T:log4net.Util.PatternParser"/> used to parse the conversion string. Sets the
+            global and instance rules on the <see cref="T:log4net.Util.PatternParser"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Parse the <see cref="T:log4net.Core.LoggingEvent"/> using the patter format
+            specified in the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternLayout
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a named pattern converter to this instance. This
+            converter will be used in the formatting of the event.
+            This method must be called before <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>.
+            </para>
+            <para>
+            The <paramref name="type"/> specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">
+            <summary>
+            The pattern formatting string
+            </summary>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_headerPatternString">
+            <summary>
+            The header PatternString
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_footerPatternString">
+            <summary>
+            The footer PatternString
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor">
+            <summary>
+            Constructs a DynamicPatternLayout using the DefaultConversionPattern
+            </summary>
+            <remarks>
+            <para>
+            The default pattern just produces the application supplied message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor(System.String)">
+            <summary>
+            Constructs a DynamicPatternLayout using the supplied conversion pattern
+            </summary>
+            <param name="pattern">the pattern to use</param>
+            <remarks>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Header">
+            <summary>
+            The header for the layout format.
+            </summary>
+            <value>the layout header</value>
+            <remarks>
+            <para>
+            The Header text will be appended before any logging events
+            are formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.DynamicPatternLayout.Footer">
+            <summary>
+            The footer for the layout format.
+            </summary>
+            <value>the layout footer</value>
+            <remarks>
+            <para>
+            The Footer text will be appended after all the logging events
+            have been formatted and appended.
+            </para>
+            The pattern will be formatted on each get operation.
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.ExceptionLayout">
+            <summary>
+            A Layout that renders only the Exception text from the logging event
+            </summary>
+            <remarks>
+            <para>
+            A Layout that renders only the Exception text from the logging event.
+            </para>
+            <para>
+            This Layout should only be used with appenders that utilize multiple
+            layouts (e.g. <see cref="T:log4net.Appender.AdoNetAppender"/>).
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Constructs a ExceptionLayout
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.ActivateOptions">
+            <summary>
+            Activate component options
+            </summary>
+            <remarks>
+            <para>
+            Part of the <see cref="T:log4net.Core.IOptionHandler"/> component activation
+            framework.
+            </para>
+            <para>
+            This method does nothing as options become effective immediately.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.ExceptionLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the exception text from the logging event
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <param name="loggingEvent">the event being logged</param>
+            <remarks>
+            <para>
+            Write the exception string to the <see cref="T:System.IO.TextWriter"/>.
+            The exception string is retrieved from <see cref="M:LoggingEvent.GetExceptionString()"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.IRawLayout">
+            <summary>
+            Interface for raw layout objects
+            </summary>
+            <remarks>
+            <para>
+            Interface used to format a <see cref="T:log4net.Core.LoggingEvent"/>
+            to an object.
+            </para>
+            <para>
+            This interface should not be confused with the
+            <see cref="T:log4net.Layout.ILayout"/> interface. This interface is used in
+            only certain specialized situations where a raw object is
+            required rather than a formatted string. The <see cref="T:log4net.Layout.ILayout"/>
+            is not generally useful than this interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.IRawLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Implement this method to create your own layout format.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Implement this method to create your own layout format.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.Layout2RawLayoutAdapter">
+            <summary>
+            Adapts any <see cref="T:log4net.Layout.ILayout"/> to a <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <remarks>
+            <para>
+            Where an <see cref="T:log4net.Layout.IRawLayout"/> is required this adapter
+            allows a <see cref="T:log4net.Layout.ILayout"/> to be specified.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Layout.Layout2RawLayoutAdapter.m_layout">
+            <summary>
+            The layout to adapt
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.#ctor(log4net.Layout.ILayout)">
+            <summary>
+            Construct a new adapter
+            </summary>
+            <param name="layout">the layout to adapt</param>
+            <remarks>
+            <para>
+            Create the adapter for the specified <paramref name="layout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Format the logging event as an object.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the formatted event</returns>
+            <remarks>
+            <para>
+            Format the logging event as an object.
+            </para>
+            <para>
+            Uses the <see cref="T:log4net.Layout.ILayout"/> object supplied to 
+            the constructor to perform the formatting.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawLayoutConverter">
+            <summary>
+            Type converter for the <see cref="T:log4net.Layout.IRawLayout"/> interface
+            </summary>
+            <remarks>
+            <para>
+            Used to convert objects to the <see cref="T:log4net.Layout.IRawLayout"/> interface.
+            Supports converting from the <see cref="T:log4net.Layout.ILayout"/> interface to
+            the <see cref="T:log4net.Layout.IRawLayout"/> interface using the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertFrom">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from arbitrary types
+            to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to the
+            type supported by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> to the type supported
+            by this converter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the sourceType be converted to an <see cref="T:log4net.Layout.IRawLayout"/>
+            </summary>
+            <param name="sourceType">the source to be to be converted</param>
+            <returns><c>true</c> if the source type can be converted to <see cref="T:log4net.Layout.IRawLayout"/></returns>
+            <remarks>
+            <para>
+            Test if the <paramref name="sourceType"/> can be converted to a
+            <see cref="T:log4net.Layout.IRawLayout"/>. Only <see cref="T:log4net.Layout.ILayout"/> is supported
+            as the <paramref name="sourceType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.RawLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the value to a <see cref="T:log4net.Layout.IRawLayout"/> object
+            </summary>
+            <param name="source">the value to convert</param>
+            <returns>the <see cref="T:log4net.Layout.IRawLayout"/> object</returns>
+            <remarks>
+            <para>
+            Convert the <paramref name="source"/> object to a 
+            <see cref="T:log4net.Layout.IRawLayout"/> object. If the <paramref name="source"/> object
+            is a <see cref="T:log4net.Layout.ILayout"/> then the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>
+            is used to adapt between the two interfaces, otherwise an
+            exception is thrown.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawPropertyLayout">
+            <summary>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.#ctor">
+            <summary>
+            Constructs a RawPropertyLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawPropertyLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Lookup the property for <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns property value</returns>
+            <remarks>
+            <para>
+            Looks up and returns the object value of the property
+            named <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>. If there is no property defined
+            with than name then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.RawPropertyLayout.Key">
+            <summary>
+            The name of the value to lookup in the LoggingEvent Properties collection.
+            </summary>
+            <value>
+            Value to lookup in the LoggingEvent Properties collection
+            </value>
+            <remarks>
+            <para>
+            String name of the property to lookup in the <see cref="T:log4net.Core.LoggingEvent"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in local time. To format the time stamp
+            in universal time use <see cref="T:log4net.Layout.RawUtcTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.RawUtcTimeStampLayout">
+            <summary>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </summary>
+            <remarks>
+            <para>
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.#ctor">
+            <summary>
+            Constructs a RawUtcTimeStampLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.Format(log4net.Core.LoggingEvent)">
+            <summary>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </summary>
+            <param name="loggingEvent">The event to format</param>
+            <returns>returns the time stamp</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.
+            </para>
+            <para>
+            The time stamp is in universal time. To format the time stamp
+            in local time use <see cref="T:log4net.Layout.RawTimeStampLayout"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.SimpleLayout">
+            <summary>
+            A very simple layout
+            </summary>
+            <remarks>
+            <para>
+            SimpleLayout consists of the level of the log statement,
+            followed by " - " and then the log message itself. For example,
+            <code>
+            DEBUG - Hello world
+            </code>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.#ctor">
+            <summary>
+            Constructs a SimpleLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a simple formatted output.
+            </summary>
+            <param name="loggingEvent">the event being logged</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Formats the event as the level of the even,
+            followed by " - " and then the log message itself. The
+            output is terminated by a newline.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayout">
+             <summary>
+             Layout that formats the log events as XML elements.
+             </summary>
+             <remarks>
+             <para>
+             The output of the <see cref="T:log4net.Layout.XmlLayout"/> consists of a series of 
+             log4net:event elements. It does not output a complete well-formed XML 
+             file. The output is designed to be included as an <em>external entity</em>
+             in a separate file to form a correct XML file.
+             </para>
+             <para>
+             For example, if <c>abc</c> is the name of the file where
+             the <see cref="T:log4net.Layout.XmlLayout"/> output goes, then a well-formed XML file would 
+             be:
+             </para>
+             <code lang="XML">
+             &lt;?xml version="1.0" ?&gt;
+             
+             &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;
+            
+             &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;
+                 &amp;data;
+             &lt;/log4net:events&gt;
+             </code>
+             <para>
+             This approach enforces the independence of the <see cref="T:log4net.Layout.XmlLayout"/> 
+             and the appender where it is embedded.
+             </para>
+             <para>
+             The <c>version</c> attribute helps components to correctly
+             interpret output generated by <see cref="T:log4net.Layout.XmlLayout"/>. The value of 
+             this attribute should be "1.2" for release 1.2 and later.
+             </para>
+             <para>
+             Alternatively the <c>Header</c> and <c>Footer</c> properties can be
+             configured to output the correct XML header, open tag and close tag.
+             When setting the <c>Header</c> and <c>Footer</c> properties it is essential
+             that the underlying data store not be appendable otherwise the data
+             will become invalid XML.
+             </para>
+             </remarks>
+             <author>Nicko Cadell</author>
+             <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutBase">
+            <summary>
+            Layout that formats the log events as XML elements.
+            </summary>
+            <remarks>
+            <para>
+            This is an abstract class that must be subclassed by an implementation 
+            to conform to a specific schema.
+            </para>
+            <para>
+            Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class
+            with no location info.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">
+            <summary>
+            Protected constructor to support subclasses
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="locationInfo" /> parameter determines whether 
+            location information will be output by the layout. If 
+            <paramref name="locationInfo" /> is set to <c>true</c>, then the 
+            file name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Produces a formatted string.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            <para>
+            This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the
+            <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed 
+            to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the
+            <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Subclasses should override this method to format
+            the <see cref="T:log4net.Core.LoggingEvent"/> as XML.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">
+            <summary>
+            Flag to indicate if location information should be included in
+            the XML events.
+            </summary>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">
+            <summary>
+            The string to replace invalid chars with
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">
+            <summary>
+            Gets a value indicating whether to include location information in 
+            the XML events.
+            </summary>
+            <value>
+            <c>true</c> if location information should be included in the XML 
+            events; otherwise, <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file 
+            name and line number of the statement at the origin of the log 
+            statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an <c>SMTPAppender</c>
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">
+            <summary>
+            The string to replace characters that can not be expressed in XML with.
+            <remarks>
+            <para>
+            Not all characters may be expressed in XML. This property contains the
+            string to replace those that can not with. This defaults to a ?. Set it
+            to the empty string to simply remove offending characters. For more
+            details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets
+            Character replacement will occur in  the log message, the property names 
+            and the property values.
+            </para>
+            </remarks>
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutBase.ContentType">
+            <summary>
+            Gets the content type output by this layout. 
+            </summary>
+            <value>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </value>
+            <remarks>
+            <para>
+            As this is the XML layout, the value is always <c>"text/xml"</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor">
+            <summary>
+            Constructs an XmlLayout
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XmlLayout.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SmtpAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.ActivateOptions">
+            <summary>
+            Initialize layout options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            Builds a cache of the element names
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayout.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Does the actual writing of the XML.
+            </summary>
+            <param name="writer">The writer to use to output the event to.</param>
+            <param name="loggingEvent">The event to write.</param>
+            <remarks>
+            <para>
+            Override the base class <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method
+            to write the <see cref="T:log4net.Core.LoggingEvent"/> to the <see cref="T:System.Xml.XmlWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Layout.XmlLayout.m_prefix">
+            <summary>
+            The prefix to use for all generated element names
+            </summary>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Prefix">
+            <summary>
+            The prefix to use for all element names
+            </summary>
+            <remarks>
+            <para>
+            The default prefix is <b>log4net</b>. Set this property
+            to change the prefix. If the prefix is set to an empty string
+            then no prefix will be written.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeMessage">
+            <summary>
+            Set whether or not to base64 encode the message.
+            </summary>
+            <remarks>
+            <para>
+            By default the log message will be written as text to the xml
+            output. This can cause problems when the message contains binary
+            data. By setting this to true the contents of the message will be
+            base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the log message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeProperties">
+            <summary>
+            Set whether or not to base64 encode the property values.
+            </summary>
+            <remarks>
+            <para>
+            By default the properties will be written as text to the xml
+            output. This can cause problems when one or more properties contain
+            binary data. By setting this to true the values of the properties
+            will be base64 encoded. If this is set then invalid character replacement
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed
+            on the property values.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Layout.XmlLayoutSchemaLog4j">
+            <summary>
+            Layout that formats the log events as XML elements compatible with the log4j schema
+            </summary>
+            <remarks>
+            <para>
+            Formats the log events according to the http://logging.apache.org/log4j schema.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Layout.XmlLayoutSchemaLog4j.s_date1970">
+            <summary>
+            The 1st of January 1970 in UTC
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j
+            </summary>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor(System.Boolean)">
+            <summary>
+            Constructs an XMLLayoutSchemaLog4j.
+            </summary>
+            <remarks>
+            <para>
+            The <b>LocationInfo</b> option takes a boolean value. By
+            default, it is set to false which means there will be no location
+            information output by this layout. If the the option is set to
+            true, then the file name and line number of the statement
+            at the origin of the log statement will be output. 
+            </para>
+            <para>
+            If you are embedding this layout within an SMTPAppender
+            then make sure to set the <b>LocationInfo</b> option of that 
+            appender as well.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
+            <summary>
+            Actually do the writing of the xml
+            </summary>
+            <param name="writer">the writer to use</param>
+            <param name="loggingEvent">the event to write</param>
+            <remarks>
+            <para>
+            Generate XML that is compatible with the log4j schema.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Layout.XmlLayoutSchemaLog4j.Version">
+            <summary>
+            The version of the log4j schema to use.
+            </summary>
+            <remarks>
+            <para>
+            Only version 1.2 of the log4j schema is supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.DefaultRenderer">
+            <summary>
+            The default object Renderer.
+            </summary>
+            <remarks>
+            <para>
+            The default renderer supports rendering objects and collections to strings.
+            </para>
+            <para>
+            See the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)"/> method for details of the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.ObjectRenderer.IObjectRenderer">
+            <summary>
+            Implement this interface in order to render objects as strings
+            </summary>
+            <remarks>
+            <para>
+            Certain types require special case conversion to
+            string form. This conversion is done by an object renderer.
+            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>
+            interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.IObjectRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a 
+            string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object, TextWriter)"/>
+            method can be used to render these objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">
+            <summary>
+            Render the object <paramref name="obj"/> to a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="obj">The object to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the object <paramref name="obj"/> to a string.
+            </para>
+            <para>
+            The <paramref name="rendererMap"/> parameter is
+            provided to lookup and render other objects. This is
+            very useful where <paramref name="obj"/> contains
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)"/>
+            method can be used to render these objects.
+            </para>
+            <para>
+            The default renderer supports rendering objects to strings as follows:
+            </para>
+            <list type="table">
+            	<listheader>
+            		<term>Value</term>
+            		<description>Rendered String</description>
+            	</listheader>
+            	<item>
+            		<term><c>null</c></term>
+            		<description>
+            		<para>"(null)"</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Array"/></term>
+            		<description>
+            		<para>
+            		For a one dimensional array this is the
+            		array type name, an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace. 
+            		</para>
+            		<para>
+            		For example: <c>int[] {1, 2, 3}</c>.
+            		</para>
+            		<para>
+            		If the array is not one dimensional the 
+            		<c>Array.ToString()</c> is returned.
+            		</para>
+            		</description>
+            	</item>
+            	<item>
+            		<term><see cref="T:System.Collections.IEnumerable"/>, <see cref="T:System.Collections.ICollection"/> &amp; <see cref="T:System.Collections.IEnumerator"/></term>
+            		<description>
+            		<para>
+            		Rendered as an open brace, followed by a comma
+            		separated list of the elements (using the appropriate
+            		renderer), followed by a close brace.
+            		</para>
+            		<para>
+            		For example: <c>{a, b, c}</c>.
+            		</para>
+            		<para>
+            		All collection classes that implement <see cref="T:System.Collections.ICollection"/> its subclasses, 
+            		or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable"/> interface.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term><see cref="T:System.Collections.DictionaryEntry"/></term>
+            		<description>
+            		<para>
+            		Rendered as the key, an equals sign ('='), and the value (using the appropriate
+            		renderer). 
+            		</para>
+            		<para>
+            		For example: <c>key=value</c>.
+            		</para>
+            		</description>
+            	</item>		
+            	<item>
+            		<term>other</term>
+            		<description>
+            		<para><c>Object.ToString()</c></para>
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array,System.IO.TextWriter)">
+            <summary>
+            Render the array argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="array">the array to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            For a one dimensional array this is the
+            array type name, an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>int[] {1, 2, 3}</c>.
+            </para>
+            <para>
+            If the array is not one dimensional the 
+            <c>Array.ToString()</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderEnumerator(log4net.ObjectRenderer.RendererMap,System.Collections.IEnumerator,System.IO.TextWriter)">
+            <summary>
+            Render the enumerator argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="enumerator">the enumerator to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Rendered as an open brace, followed by a comma
+            separated list of the elements (using the appropriate
+            renderer), followed by a close brace. For example:
+            <c>{a, b, c}</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderDictionaryEntry(log4net.ObjectRenderer.RendererMap,System.Collections.DictionaryEntry,System.IO.TextWriter)">
+            <summary>
+            Render the DictionaryEntry argument into a string
+            </summary>
+            <param name="rendererMap">The map used to lookup renderers</param>
+            <param name="entry">the DictionaryEntry to render</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Render the key, an equals sign ('='), and the value (using the appropriate
+            renderer). For example: <c>key=value</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.ObjectRenderer.RendererMap">
+            <summary>
+            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a mapping between types that require special
+            rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that
+            is used to render them.
+            </para>
+            <para>
+            The <see cref="M:FindAndRender(object)"/> method is used to render an
+            <c>object</c> using the appropriate renderers defined in this map.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <returns>the object rendered as a string</returns>
+            <remarks>
+            <para>
+            This is a convenience method used to render an object to a string.
+            The alternative method <see cref="M:FindAndRender(object,TextWriter)"/>
+            should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">
+            <summary>
+            Render <paramref name="obj"/> using the appropriate renderer.
+            </summary>
+            <param name="obj">the object to render to a string</param>
+            <param name="writer">The writer to render to</param>
+            <remarks>
+            <para>
+            Find the appropriate renderer for the type of the
+            <paramref name="obj"/> parameter. This is accomplished by calling the
+            <see cref="M:Get(Type)"/> method. Once a renderer is found, it is
+            applied on the object <paramref name="obj"/> and the result is returned
+            as a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
+            <summary>
+            Gets the renderer for the specified object type
+            </summary>
+            <param name="obj">the object to lookup the renderer for</param>
+            <returns>the renderer for <paramref name="obj"/></returns>
+            <remarks>
+            <param>
+            Gets the renderer for the specified object type.
+            </param>
+            <param>
+            Syntactic sugar method that calls <see cref="M:Get(Type)"/> 
+            with the type of the object parameter.
+            </param>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
+            <summary>
+            Gets the renderer for the specified type
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+            <remarks>
+            <para>
+            Returns the renderer for the specified type.
+            If no specific renderer has been defined the
+            <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">
+            <summary>
+            Internal function to recursively search interfaces
+            </summary>
+            <param name="type">the type to lookup the renderer for</param>
+            <returns>the renderer for the specified type</returns>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
+            <summary>
+            Clear the map of renderers
+            </summary>
+            <remarks>
+            <para>
+            Clear the custom renderers defined by using
+            <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>
+            cannot be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>. 
+            </summary>
+            <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>
+            <param name="renderer">the renderer for <paramref name="typeToRender"/></param>
+            <remarks>
+            <para>
+            Register an object renderer for a specific source type.
+            This renderer will be returned from a call to <see cref="M:Get(Type)"/>
+            specifying the same <paramref name="typeToRender"/> as an argument.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
+            <summary>
+            Get the default renderer instance
+            </summary>
+            <value>the default renderer</value>
+            <remarks>
+            <para>
+            Get the default renderer
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.IPlugin">
+            <summary>
+            Interface implemented by logger repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            Plugins define additional behavior that can be associated
+            with a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            The <see cref="T:log4net.Plugin.PluginMap"/> held by the <see cref="P:log4net.Repository.ILoggerRepository.PluginMap"/>
+            property is used to store the plugins for a repository.
+            </para>
+            <para>
+            The <c>log4net.Config.PluginAttribute</c> can be used to
+            attach plugins to repositories created using configuration
+            attributes.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches the plugin to the specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.IPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.IPlugin.Name">
+            <summary>
+            Gets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection">
+            <summary>
+            A strongly-typed collection of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ReadOnly(log4net.Plugin.PluginCollection)">
+            <summary>
+            Creates a read-only wrapper for a <c>PluginCollection</c> instance.
+            </summary>
+            <param name="list">list to create a readonly wrapper arround</param>
+            <returns>
+            A <c>PluginCollection</c> wrapper that is read-only.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that is empty and has the default initial capacity.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Int32)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that has the specified initial capacity.
+            </summary>
+            <param name="capacity">
+            The number of elements that the new <c>PluginCollection</c> is initially capable of storing.
+            </param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <c>PluginCollection</c>.
+            </summary>
+            <param name="c">The <c>PluginCollection</c> whose elements are copied to the new collection.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.IPlugin[])">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="a">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Collections.ICollection)">
+            <summary>
+            Initializes a new instance of the <c>PluginCollection</c> class
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> collection.
+            </summary>
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements are copied to the new list.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection.Tag)">
+            <summary>
+            Allow subclasses to avoid our default constructors
+            </summary>
+            <param name="tag"></param>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[])">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[],System.Int32)">
+            <summary>
+            Copies the entire <c>PluginCollection</c> to a one-dimensional
+            <see cref="T:log4net.Plugin.IPlugin"/> array, starting at the specified index of the target array.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the end of the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to be added to the end of the <c>PluginCollection</c>.</param>
+            <returns>The index at which the value has been added.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clear">
+            <summary>
+            Removes all elements from the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Clone">
+            <summary>
+            Creates a shallow copy of the <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <returns>A new <see cref="T:log4net.Plugin.PluginCollection"/> with a shallow copy of the collection data.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Contains(log4net.Plugin.IPlugin)">
+            <summary>
+            Determines whether a given <see cref="T:log4net.Plugin.IPlugin"/> is in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to check for.</param>
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>PluginCollection</c>; otherwise, <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IndexOf(log4net.Plugin.IPlugin)">
+            <summary>
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Plugin.IPlugin"/>
+            in the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to locate in the <c>PluginCollection</c>.</param>
+            <returns>
+            The zero-based index of the first occurrence of <paramref name="item"/> 
+            in the entire <c>PluginCollection</c>, if found; otherwise, -1.
+            </returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Insert(System.Int32,log4net.Plugin.IPlugin)">
+            <summary>
+            Inserts an element into the <c>PluginCollection</c> at the specified index.
+            </summary>
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to insert.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes the first occurrence of a specific <see cref="T:log4net.Plugin.IPlugin"/> from the <c>PluginCollection</c>.
+            </summary>
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the <c>PluginCollection</c>.</param>
+            <exception cref="T:System.ArgumentException">
+            The specified <see cref="T:log4net.Plugin.IPlugin"/> was not found in the <c>PluginCollection</c>.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.RemoveAt(System.Int32)">
+            <summary>
+            Removes the element at the specified index of the <c>PluginCollection</c>.
+            </summary>
+            <param name="index">The zero-based index of the element to remove.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through the <c>PluginCollection</c>.
+            </summary>
+            <returns>An <see cref="T:log4net.Plugin.PluginCollection.Enumerator"/> for the entire <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.PluginCollection)">
+            <summary>
+            Adds the elements of another <c>PluginCollection</c> to the current <c>PluginCollection</c>.
+            </summary>
+            <param name="x">The <c>PluginCollection</c> whose elements should be added to the end of the current <c>PluginCollection</c>.</param>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.IPlugin[])">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> array to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(System.Collections.ICollection)">
+            <summary>
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> collection to the current <c>PluginCollection</c>.
+            </summary>
+            <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>
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.TrimToSize">
+            <summary>
+            Sets the capacity to the actual number of elements.
+            </summary>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32,System.Boolean)">
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="i"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Count">
+            <summary>
+            Gets the number of elements actually contained in the <c>PluginCollection</c>.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).
+            </summary>
+            <returns>false, because the backing type is an array, which is never thread-safe.</returns>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the collection.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the collection.
+            </value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Item(System.Int32)">
+            <summary>
+            Gets or sets the <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.
+            </value>
+            <param name="index">The zero-based index of the element to get or set.</param>
+            <exception cref="T:System.ArgumentOutOfRangeException">
+            <para><paramref name="index"/> is less than zero.</para>
+            <para>-or-</para>
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>
+            </exception>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the collection has a fixed size.
+            </summary>
+            <value><c>true</c> if the collection has a fixed size; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the IList is read-only.
+            </summary>
+            <value><c>true</c> if the collection is read-only; otherwise, <c>false</c>. The default is <c>false</c>.</value>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Capacity">
+            <summary>
+            Gets or sets the number of elements the <c>PluginCollection</c> can contain.
+            </summary>
+            <value>
+            The number of elements the <c>PluginCollection</c> can contain.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator">
+            <summary>
+            Supports type-safe iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Tag">
+            <summary>
+            Type visible only to our subclasses
+            Used to access protected constructor
+            </summary>
+            <exclude/>
+        </member>
+        <member name="F:log4net.Plugin.PluginCollection.Tag.Default">
+            <summary>
+            A value
+            </summary>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.Enumerator">
+            <summary>
+            Supports simple iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.
+            </summary>
+            <exclude/>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.#ctor(log4net.Plugin.PluginCollection)">
+            <summary>
+            Initializes a new instance of the <c>Enumerator</c> class.
+            </summary>
+            <param name="tc"></param>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.MoveNext">
+            <summary>
+            Advances the enumerator to the next element in the collection.
+            </summary>
+            <returns>
+            <c>true</c> if the enumerator was successfully advanced to the next element; 
+            <c>false</c> if the enumerator has passed the end of the collection.
+            </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The collection was modified after the enumerator was created.
+            </exception>
+        </member>
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.Reset">
+            <summary>
+            Sets the enumerator to its initial position, before the first element in the collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginCollection.Enumerator.Current">
+            <summary>
+            Gets the current element in the collection.
+            </summary>
+            <value>
+            The current element in the collection.
+            </value>
+        </member>
+        <member name="T:log4net.Plugin.PluginCollection.ReadOnlyPluginCollection">
+            <exclude/>
+        </member>
+        <member name="T:log4net.Plugin.PluginMap">
+            <summary>
+            Map of repository plugins.
+            </summary>
+            <remarks>
+            <para>
+            This class is a name keyed map of the plugins that are
+            attached to a repository.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository that the plugins should be attached to.</param>
+            <remarks>
+            <para>
+            Initialize a new instance of the <see cref="T:log4net.Plugin.PluginMap"/> class with a 
+            repository that the plugins should be attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Add(log4net.Plugin.IPlugin)">
+            <summary>
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to add to the map.</param>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Plugin.IPlugin"/> will be attached to the repository when added.
+            </para>
+            <para>
+            If there already exists a plugin with the same name 
+            attached to the repository then the old plugin will
+            be <see cref="M:log4net.Plugin.IPlugin.Shutdown"/> and replaced with
+            the new plugin.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginMap.Remove(log4net.Plugin.IPlugin)">
+            <summary>
+            Removes a <see cref="T:log4net.Plugin.IPlugin"/> from the map.
+            </summary>
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the map.</param>
+            <remarks>
+            <para>
+            Remove a specific plugin from this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.Item(System.String)">
+            <summary>
+            Gets a <see cref="T:log4net.Plugin.IPlugin"/> by name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Plugin.IPlugin"/> to lookup.</param>
+            <returns>
+            The <see cref="T:log4net.Plugin.IPlugin"/> from the map with the name specified, or 
+            <c>null</c> if no plugin is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup a plugin by name. If the plugin is not found <c>null</c>
+            will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginMap.AllPlugins">
+            <summary>
+            Gets all possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.
+            </summary>
+            <value>All possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.</value>
+            <remarks>
+            <para>
+            Get a collection of all the plugins defined in this map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.PluginSkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Plugin.IPlugin"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Plugin.IPlugin"/>
+            interface. This base class can be used by implementors
+            of the <see cref="T:log4net.Plugin.IPlugin"/> interface.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="name">the name of the plugin</param>
+            <remarks>
+            Initializes a new Plugin with the specified name.
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.PluginSkeleton.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            This method is called to notify the plugin that 
+            it should stop operating and should detach from
+            the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_name">
+            <summary>
+            The name of this plugin.
+            </summary>
+        </member>
+        <member name="F:log4net.Plugin.PluginSkeleton.m_repository">
+            <summary>
+            The repository this plugin is attached to.
+            </summary>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.Name">
+            <summary>
+            Gets or sets the name of the plugin.
+            </summary>
+            <value>
+            The name of the plugin.
+            </value>
+            <remarks>
+            <para>
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>
+            keyed by name. Each plugin instance attached to a
+            repository must be a unique name.
+            </para>
+            <para>
+            The name of the plugin must not change one the 
+            plugin has been attached to a repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.PluginSkeleton.LoggerRepository">
+            <summary>
+            The repository for this plugin
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is attached to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is 
+            attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin">
+            <summary>
+            Plugin that listens for events from the <see cref="T:log4net.Appender.RemotingAppender"/>
+            </summary>
+            <remarks>
+            <para>
+            This plugin publishes an instance of <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/> 
+            on a specified <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/>. This listens for logging events delivered from
+            a remote <see cref="T:log4net.Appender.RemotingAppender"/>.
+            </para>
+            <para>
+            When an event is received it is relogged within the attached repository
+            as if it had been raised locally.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class.
+            </para>
+            <para>
+            The <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> property must be set.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor(System.String)">
+            <summary>
+            Construct with sink Uri.
+            </summary>
+            <param name="sinkUri">The name to publish the sink under in the remoting infrastructure. 
+            See <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> for more details.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class
+            with specified name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Attach(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>
+            <remarks>
+            <para>
+            A plugin may only be attached to a single repository.
+            </para>
+            <para>
+            This method is called when the plugin is attached to the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Shutdown">
+            <summary>
+            Is called when the plugin is to shutdown.
+            </summary>
+            <remarks>
+            <para>
+            When the plugin is shutdown the remote logging
+            sink is disconnected.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.declaringType">
+            <summary>
+            The fully qualified type of the RemoteLoggingServerPlugin class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri">
+            <summary>
+            Gets or sets the URI of this sink.
+            </summary>
+            <value>
+            The URI of this sink.
+            </value>
+            <remarks>
+            <para>
+            This is the name under which the object is marshaled.
+            <see cref="M:RemotingServices.Marshal(MarshalByRefObject,String,Type)"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl">
+            <summary>
+            Delivers <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to listen for logging events
+            and deliver them to the local repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.#ctor(log4net.Repository.ILoggerRepository)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="repository">The repository to log to.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl"/> for the
+            specified <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.LogEvents(log4net.Core.LoggingEvent[])">
+            <summary>
+            Logs the events to the repository.
+            </summary>
+            <param name="events">The events to log.</param>
+            <remarks>
+            <para>
+            The events passed are logged to the <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.InitializeLifetimeService">
+            <summary>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance.
+            </summary>
+            <returns><c>null</c> to indicate that this instance should live forever.</returns>
+            <remarks>
+            <para>
+            Obtains a lifetime service object to control the lifetime 
+            policy for this instance. This object should live forever
+            therefore this implementation returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.m_repository">
+            <summary>
+            The underlying <see cref="T:log4net.Repository.ILoggerRepository"/> that events should
+            be logged to.
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">
+            <summary>
+            Default implementation of <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            </summary>
+            <remarks>
+            <para>
+            This default implementation of the <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            interface is used to create the default subclass
+            of the <see cref="T:log4net.Repository.Hierarchy.Logger"/> object.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">
+            <summary>
+            Interface abstracts creation of <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances
+            </summary>
+            <remarks>
+            <para>
+            This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to 
+            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.
+            </para>
+            <para>
+            The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)"/> method is called
+            to create a named <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            <para>
+            Implement this interface to create new subclasses of <see cref="T:log4net.Repository.Hierarchy.Logger"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">
+            <summary>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance
+            </summary>
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>
+            <remarks>
+            <para>
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the 
+            specified name.
+            </para>
+            <para>
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.
+            </para>
+            <para>
+            If the <paramref name="name"/> is <c>null</c> then the root logger
+            must be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl">
+            <summary>
+            Default internal subclass of <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            </summary>
+            <remarks>
+            <para>
+            This subclass has no additional behavior over the
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> class but does allow instances
+            to be created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Logger">
+            <summary>
+            Implementation of <see cref="T:log4net.Core.ILogger"/> used by <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to provide implementation of <see cref="T:log4net.Core.ILogger"/>
+            interface. Applications should use <see cref="T:log4net.LogManager"/> to get
+            logger instances.
+            </para>
+            <para>
+            This is one of the central classes in the log4net implementation. One of the
+            distinctive features of log4net are hierarchical loggers and their
+            evaluation. The <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> organizes the <see cref="T:log4net.Repository.Hierarchy.Logger"/>
+            instances into a rooted tree hierarchy.
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.Logger"/> class is abstract. Only concrete subclasses of
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> can be created. The <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
+            is used to create instances of this type for the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Aspi Havewala</author>
+            <author>Douglas de la Torre</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">
+            <summary>
+            This constructor created a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance and
+            sets its name.
+            </summary>
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>
+            <remarks>
+            <para>
+            This constructor is protected and designed to be used by
+            a subclass that is not abstract.
+            </para>
+            <para>
+            Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> 
+            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default
+            logger creator.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </summary>
+            <param name="newAppender">An appender to add to this logger</param>
+            <remarks>
+            <para>
+            Add <paramref name="newAppender"/> to the list of appenders of this
+            Logger instance.
+            </para>
+            <para>
+            If <paramref name="newAppender"/> is already in the list of
+            appenders, then it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">
+            <summary>
+            Look for the appender named as <c>name</c>
+            </summary>
+            <param name="name">The name of the appender to lookup</param>
+            <returns>The appender with the name specified, or <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Returns the named appender, or null if the appender is not found.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">
+            <summary>
+            Remove all previously added appenders from this Logger instance.
+            </summary>
+            <remarks>
+            <para>
+            Remove all previously added appenders from this Logger instance.
+            </para>
+            <para>
+            This is useful when re-reading configuration information.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="appender">The appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">
+            <summary>
+            Remove the appender passed as parameter form the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            Remove the named appender passed as parameter form the list of appenders.
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This generic form is intended to be used by wrappers.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/> and <paramref name="exception"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            This is the most generic printing method that is intended to be used 
+            by wrappers.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Logs the specified logging event through this logger.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.Core.Level)">
+            <summary>
+            Checks if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
+            </summary>
+            <param name="level">The level to check.</param>
+            <returns>
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
+            </returns>
+            <remarks>
+            <para>
+            Test if this logger is going to log events of the specified <paramref name="level"/>.
+            </para>
+            <para>
+            This method must not throw any exception to the caller.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Deliver the <see cref="T:log4net.Core.LoggingEvent"/> to the attached appenders.
+            </summary>
+            <param name="loggingEvent">The event to log.</param>
+            <remarks>
+            <para>
+            Call the appenders in the hierarchy starting at
+            <c>this</c>. If no appenders could be found, emit a
+            warning.
+            </para>
+            <para>
+            This method calls all the appenders inherited from the
+            hierarchy circumventing any evaluation of whether to log or not
+            to log the particular log request.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">
+            <summary>
+            Closes all attached appenders implementing the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            Used to ensure that the appenders are correctly shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            This is the most generic printing method. This generic form is intended to be used by wrappers
+            </summary>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generate a logging event for the specified <paramref name="level"/> using
+            the <paramref name="message"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.Type,log4net.Core.Level,System.Object,System.Exception)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
+            the stack boundary into the logging system for this call.</param>
+            <param name="level">The level of the message to be logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            Generates a logging event and delivers it to the attached
+            appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.Core.LoggingEvent)">
+            <summary>
+            Creates a new logging event and logs the event without further checks.
+            </summary>
+            <param name="logEvent">The event being logged.</param>
+            <remarks>
+            <para>
+            Delivers the logging event to the attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">
+            <summary>
+            The name of this logger.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">
+            <summary>
+            The assigned level of this logger. 
+            </summary>
+            <remarks>
+            <para>
+            The <c>level</c> variable need not be 
+            assigned a value in which case it is inherited 
+            form the hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">
+            <summary>
+            The parent of this logger.
+            </summary>
+            <remarks>
+            <para>
+            The parent of this logger. 
+            All loggers have at least one ancestor which is the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">
+            <summary>
+            Loggers need to know what Hierarchy they are in.
+            </summary>
+            <remarks>
+            <para>
+            Loggers need to know what Hierarchy they are in.
+            The hierarchy that this logger is a member of is stored
+            here.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderAttachedImpl">
+            <summary>
+            Helper implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">
+            <summary>
+            Flag indicating if child loggers inherit their parents appenders
+            </summary>
+            <remarks>
+            <para>
+            Additivity is set to true by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderLock">
+            <summary>
+            Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl
+            </summary>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">
+            <summary>
+            Gets or sets the parent logger in the hierarchy.
+            </summary>
+            <value>
+            The parent logger in the hierarchy.
+            </value>
+            <remarks>
+            <para>
+            Part of the Composite pattern that makes the hierarchy.
+            The hierarchy is parent linked rather than child linked.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">
+            <summary>
+            Gets or sets a value indicating if child loggers inherit their parent's appenders.
+            </summary>
+            <value>
+            <c>true</c> if child loggers inherit their parent's appenders.
+            </value>
+            <remarks>
+            <para>
+            Additivity is set to <c>true</c> by default, that is children inherit
+            the appenders of their ancestors by default. If this variable is
+            set to <c>false</c> then the appenders found in the
+            ancestors of this logger are not used. However, the children
+            of this logger will inherit its appenders, unless the children
+            have their additivity flag set to <c>false</c> too. See
+            the user manual for more details.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.EffectiveLevel">
+            <summary>
+            Gets the effective level for this logger.
+            </summary>
+            <returns>The nearest level in the logger hierarchy.</returns>
+            <remarks>
+            <para>
+            Starting from this logger, searches the logger hierarchy for a
+            non-null level and returns it. Otherwise, returns the level of the
+            root logger.
+            </para>
+            <para>The Logger class is designed so that this method executes as
+            quickly as possible.</para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">
+            <summary>
+            Gets or sets the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>The hierarchy that this logger belongs to.</value>
+            <remarks>
+            <para>
+            This logger must be attached to a single <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.
+            </value>
+            <remarks>
+            <para>
+            The assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> can be <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Appenders">
+            <summary>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <returns>A collection of the appenders in this logger</returns>
+            <remarks>
+            <para>
+            Get the appenders contained in this logger as an 
+            <see cref="T:System.Collections.ICollection"/>. If no appenders 
+            can be found, then a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Name">
+            <summary>
+            Gets the logger name.
+            </summary>
+            <value>
+            The name of the logger.
+            </value>
+            <remarks>
+            <para>
+            The name of this logger
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Logger.Repository">
+            <summary>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </summary>
+            <value>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.
+            </value>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this 
+            <c>Logger</c> instance is attached to.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl.#ctor(System.String)">
+            <summary>
+            Construct a new Logger
+            </summary>
+            <param name="name">the name of the logger</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl"/> class
+            with the specified name. 
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
+            <summary>
+            Delegate used to handle logger creation event notifications.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> in which the <see cref="T:log4net.Repository.Hierarchy.Logger"/> has been created.</param>
+            <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args that hold the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger creation event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
+            <summary>
+            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a
+            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
+            <summary>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument 
+            class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
+            <summary>
+            Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </value>
+            <remarks>
+            <para>
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy">
+            <summary>
+            Hierarchical organization of loggers
+            </summary>
+            <remarks>
+            <para>
+            <i>The casual user should not have to deal with this class
+            directly.</i>
+            </para>
+            <para>
+            This class is specialized in retrieving loggers by name and
+            also maintaining the logger hierarchy. Implements the 
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            The structure of the logger hierarchy is maintained by the
+            <see cref="M:GetLogger(string)"/> method. The hierarchy is such that children
+            link to their parent but parents do not have any references to their
+            children. Moreover, loggers can be instantiated in any order, in
+            particular descendant before ancestor.
+            </para>
+            <para>
+            In case a descendant is created before a particular ancestor,
+            then it creates a provision node for the ancestor and adds itself
+            to the provision node. Other descendants of the same ancestor add
+            themselves to the previously created provision node.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositorySkeleton">
+            <summary>
+            Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>
+            </summary>
+            <remarks>
+            <para>
+            Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            </para>
+            <para>
+            Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
+            All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Repository.ILoggerRepository">
+            <summary>
+            Interface implemented by logger repositories.
+            </summary>
+            <remarks>
+            <para>
+            This interface is implemented by logger repositories. e.g. 
+            <see cref="N:log4net.Repository.Hierarchy"/>.
+            </para>
+            <para>
+            This interface is used by the <see cref="T:log4net.LogManager"/>
+            to obtain <see cref="T:log4net.ILog"/> interfaces.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
+            <summary>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If the names logger exists it is returned, otherwise
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers as an Array.
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
+            <summary>
+            Returns a named logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Returns a named logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
+            <summary>Shutdown the repository</summary>
+            <remarks>
+            <para>
+            Shutting down a repository will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <see cref="M:Shutdown()"/> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of the repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.ConfigurationMessages">
+            <summary>
+            Collection of internal messages captured during the most 
+            recent configuration process.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.ILoggerRepository.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            <para>
+            These properties can be specified on a repository specific basis.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes the repository with default (empty) properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct the repository using specific properties
+            </summary>
+            <param name="properties">the properties to set for this repository</param>
+            <remarks>
+            <para>
+            Initializes the repository with specified properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
+            <summary>
+            Test if logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the repository. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the repository
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the repository as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Return a new logger instance.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
+            <summary>
+            Shutdown the repository
+            </summary>
+            <remarks>
+            <para>
+            Shutdown the repository. Can be overridden in a subclass.
+            This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>
+            listeners and all attached plugins of the shutdown event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
+            <summary>
+            Reset the repositories configuration to a default state
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this instance to their
+            default state.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this repository.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">
+            <summary>
+            Returns all the Appenders that are configured as an Array.
+            </summary>
+            <returns>All the Appenders</returns>
+            <remarks>
+            <para>
+            Returns all the Appenders that are configured as an Array.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.LoggerRepositorySkeleton.declaringType">
+            <summary>
+            The fully qualified type of the LoggerRepositorySkeleton class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
+            <summary>
+            Adds an object renderer for a specific class. 
+            </summary>
+            <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>
+            <param name="rendererInstance">The object renderer used to render the object.</param>
+            <remarks>
+            <para>
+            Adds an object renderer for a specific class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository is shutting down
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository is shutting down.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration reset
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has been reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">
+            <summary>
+            Notify the registered listeners that the repository has had its configuration changed
+            </summary>
+            <param name="e">Empty EventArgs</param>
+            <remarks>
+            <para>
+            Notify any listeners that this repository's configuration has changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">
+            <summary>
+            Raise a configuration changed event on this repository
+            </summary>
+            <param name="e">EventArgs.Empty</param>
+            <remarks>
+            <para>
+            Applications that programmatically change the configuration of the repository should
+            raise this event notification to notify listeners.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Flush(System.Int32)">
+            <summary>
+            Flushes all configured Appenders that implement <see cref="T:log4net.Appender.IFlushable"/>.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed,
+            or <see cref="F:System.Threading.Timeout.Infinite"/> to wait indefinitely.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
+            <summary>
+            The name of the repository
+            </summary>
+            <value>
+            The string name of the repository
+            </value>
+            <remarks>
+            <para>
+            The name of this repository. The name is
+            used to store and lookup the repositories 
+            stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
+            <summary>
+            The threshold for all events in this repository
+            </summary>
+            <value>
+            The threshold for all events in this repository
+            </value>
+            <remarks>
+            <para>
+            The threshold for all events in this repository
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
+            <summary>
+            RendererMap accesses the object renderer map for this repository.
+            </summary>
+            <value>
+            RendererMap accesses the object renderer map for this repository.
+            </value>
+            <remarks>
+            <para>
+            RendererMap accesses the object renderer map for this repository.
+            </para>
+            <para>
+            The RendererMap holds a mapping between types and
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">
+            <summary>
+            The plugin map for this repository.
+            </summary>
+            <value>
+            The plugin map for this repository.
+            </value>
+            <remarks>
+            <para>
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
+            that have been attached to this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">
+            <summary>
+            Get the level map for the Repository.
+            </summary>
+            <remarks>
+            <para>
+            Get the level map for the Repository.
+            </para>
+            <para>
+            The level map defines the mappings between
+            level names and <see cref="T:log4net.Core.Level"/> objects in
+            this repository.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">
+            <summary>
+            Flag indicates if this repository has been configured.
+            </summary>
+            <value>
+            Flag indicates if this repository has been configured.
+            </value>
+            <remarks>
+            <para>
+            Flag indicates if this repository has been configured.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.ConfigurationMessages">
+            <summary>
+            Contains a list of internal messages captures during the 
+            last configuration.
+            </summary>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">
+            <summary>
+            Event to notify that the repository has been shutdown.
+            </summary>
+            <value>
+            Event to notify that the repository has been shutdown.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository has been shutdown.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">
+            <summary>
+            Event to notify that the repository has had its configuration reset.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration reset.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been
+            reset to default.
+            </para>
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">
+            <summary>
+            Event to notify that the repository has had its configuration changed.
+            </summary>
+            <value>
+            Event to notify that the repository has had its configuration changed.
+            </value>
+            <remarks>
+            <para>
+            Event raised when the repository's configuration has been changed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">
+            <summary>
+            Repository specific properties
+            </summary>
+            <value>
+            Repository specific properties
+            </value>
+            <remarks>
+            These properties can be specified on a repository specific basis
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
+            <summary>
+            Basic Configurator interface for repositories
+            </summary>
+            <remarks>
+            <para>
+            Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>
+            with a default <see cref="T:log4net.Appender.IAppender"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the repository using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the repository using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            Configure the repository to route all logging events to the
+            specified appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.IXmlRepositoryConfigurator">
+            <summary>
+            Configure repository using XML
+            </summary>
+            <remarks>
+            <para>
+            Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.
+            </para>
+            <para>
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
+            configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the repository using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            The schema for the XML configuration data is defined by
+            the implementation.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Construct with properties
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with a logger factory
+            </summary>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Construct with properties and a logger factory
+            </summary>
+            <param name="properties">The properties to pass to this repository.</param>
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with 
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
+            <summary>
+            Test if a logger exists
+            </summary>
+            <param name="name">The name of the logger to lookup</param>
+            <returns>The Logger object with the name specified</returns>
+            <remarks>
+            <para>
+            Check if the named logger exists in the hierarchy. If so return
+            its reference, otherwise returns <c>null</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
+            <summary>
+            Returns all the currently defined loggers in the hierarchy as an Array
+            </summary>
+            <returns>All the defined loggers</returns>
+            <remarks>
+            <para>
+            Returns all the currently defined loggers in the hierarchy as an Array.
+            The root logger is <b>not</b> included in the returned
+            enumeration.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </summary>
+            <remarks>
+            <para>
+            Return a new logger instance named as the first parameter using
+            the default factory.
+            </para>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned.  Otherwise, a new logger will be instantiated and
+            then linked with its existing ancestors as well as children.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve</param>
+            <returns>The logger object with the name specified</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
+            <summary>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </summary>
+            <remarks>
+            <para>
+            Shutting down a hierarchy will <i>safely</i> close and remove
+            all appenders in all loggers including the root logger.
+            </para>
+            <para>
+            Some appenders need to be closed before the
+            application exists. Otherwise, pending logging events might be
+            lost.
+            </para>
+            <para>
+            The <c>Shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
+            <summary>
+            Reset all values contained in this hierarchy instance to their default.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in this hierarchy instance to their
+            default.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set its default "off" value.
+            </para>
+            <para>
+            Existing loggers are not removed. They are just reset.
+            </para>
+            <para>
+            This method should be used sparingly and with care as it will
+            block all logging until it is completed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">
+            <summary>
+            Log the logEvent through this hierarchy.
+            </summary>
+            <param name="logEvent">the event to log</param>
+            <remarks>
+            <para>
+            This method should not normally be used to log.
+            The <see cref="T:log4net.ILog"/> interface should be used 
+            for routine logging. This interface can be obtained
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.
+            </para>
+            <para>
+            The <c>logEvent</c> is delivered to the appropriate logger and
+            that logger is then responsible for logging the event.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">
+            <summary>
+            Returns all the Appenders that are currently configured
+            </summary>
+            <returns>An array containing all the currently configured appenders</returns>
+            <remarks>
+            <para>
+            Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.
+            All the loggers are searched for appenders. The appenders may also be containers
+            for appenders and these are also searched for additional loggers.
+            </para>
+            <para>
+            The list returned is unordered but does not contain duplicates.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.
+            The appender may also be a container.
+            </summary>
+            <param name="appenderList"></param>
+            <param name="appender"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">
+            <summary>
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container
+            </summary>
+            <param name="appenderList"></param>
+            <param name="container"></param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
+            <summary>
+            Initialize the log4net system using the specified appender
+            </summary>
+            <param name="appender">the appender to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender[])">
+            <summary>
+            Initialize the log4net system using the specified appenders
+            </summary>
+            <param name="appenders">the appenders to use to log all logging events</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">
+            <summary>
+            Initialize the log4net system using the specified config
+            </summary>
+            <param name="element">the element containing the root of the config</param>
+            <remarks>
+            <para>
+            This method provides the same functionality as the 
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented
+            on this object, but it is protected and therefore can be called by subclasses.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">
+            <summary>
+            Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.
+            </summary>
+            <param name="level">The level to check against.</param>
+            <returns>
+            <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.
+            </returns>
+            <remarks>
+            <para>
+            If this hierarchy has not been configured then this method will
+            always return <c>true</c>.
+            </para>
+            <para>
+            This method will return <c>true</c> if this repository is
+            disabled for <c>level</c> object passed as parameter and
+            <c>false</c> otherwise.
+            </para>
+            <para>
+            See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
+            <summary>
+            Clear all logger definitions from the internal hashtable
+            </summary>
+            <remarks>
+            <para>
+            This call will clear all logger definitions from the internal
+            hashtable. Invoking this method will irrevocably mess up the
+            logger hierarchy.
+            </para>
+            <para>
+            You should <b>really</b> know what you are doing before
+            invoking this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
+            <summary>
+            Return a new logger instance named as the first parameter using
+            <paramref name="factory"/>.
+            </summary>
+            <param name="name">The name of the logger to retrieve</param>
+            <param name="factory">The factory that will make the new logger instance</param>
+            <returns>The logger object with the name specified</returns>
+            <remarks>
+            <para>
+            If a logger of that name already exists, then it will be
+            returned. Otherwise, a new logger will be instantiated by the
+            <paramref name="factory"/> parameter and linked with its existing
+            ancestors as well as children.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Sends a logger creation event to all registered listeners
+            </summary>
+            <param name="logger">The newly created logger</param>
+            <remarks>
+            Raises the logger creation event.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Updates all the parents of the specified logger
+            </summary>
+            <param name="log">The logger to update the parents for</param>
+            <remarks>
+            <para>
+            This method loops through all the <i>potential</i> parents of
+            <paramref name="log"/>. There 3 possible cases:
+            </para>
+            <list type="number">
+            	<item>
+            		<term>No entry for the potential parent of <paramref name="log"/> exists</term>
+            		<description>
+            		We create a ProvisionNode for this potential 
+            		parent and insert <paramref name="log"/> in that provision node.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type Logger for the potential parent.</term>
+            		<description>
+            		The entry is <paramref name="log"/>'s nearest existing parent. We 
+            		update <paramref name="log"/>'s parent field with this entry. We also break from 
+            		he loop because updating our parent's parent is our parent's 
+            		responsibility.
+            		</description>
+            	</item>
+            	<item>
+            		<term>The entry is of type ProvisionNode for this potential parent.</term>
+            		<description>
+            		We add <paramref name="log"/> to the list of children for this 
+            		potential parent.
+            		</description>
+            	</item>
+            </list>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
+            </summary>
+            <param name="pn"></param>
+            <param name="log"></param>
+            <remarks>
+            <para>
+            We update the links for all the children that placed themselves
+            in the provision node 'pn'. The second argument 'log' is a
+            reference for the newly created Logger, parent of all the
+            children in 'pn'.
+            </para>
+            <para>
+            We loop on all the children 'c' in 'pn'.
+            </para>
+            <para>
+            If the child 'c' has been already linked to a child of
+            'log' then there is no need to update 'c'.
+            </para>
+            <para>
+            Otherwise, we set log's parent field to c's parent and set
+            c's parent field to log.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">
+            <summary>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="levelEntry">the level values</param>
+            <remarks>
+            <para>
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </para>
+            <para>
+            Supports setting levels via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
+            </summary>
+            <param name="propertyEntry">the property value</param>
+            <remarks>
+            <para>
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.
+            </para>
+            <para>
+            Supports setting property values via the configuration file.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.Hierarchy.declaringType">
+            <summary>
+            The fully qualified type of the Hierarchy class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">
+            <summary>
+            Event used to notify that a logger has been created.
+            </summary>
+            <remarks>
+            <para>
+            Event raised when a logger is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
+            <summary>
+            Has no appender warning been emitted
+            </summary>
+            <remarks>
+            <para>
+            Flag to indicate if we have already issued a warning
+            about not having an appender warning.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
+            <summary>
+            Get the root of this hierarchy
+            </summary>
+            <remarks>
+            <para>
+            Get the root of this hierarchy.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
+            <summary>
+            Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.
+            </summary>
+            <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>
+            <remarks>
+            <para>
+            The logger factory is used to create logger instances.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">
+            <summary>
+            A class to hold the value, name and display name for a level
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the value, name and display name for a level
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">
+            <summary>
+            Value of the level
+            </summary>
+            <remarks>
+            <para>
+            If the value is not set (defaults to -1) the value will be looked
+            up for the current level with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">
+            <summary>
+            Name of the level
+            </summary>
+            <value>
+            The name of the level
+            </value>
+            <remarks>
+            <para>
+            The name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">
+            <summary>
+            Display name for the level
+            </summary>
+            <value>
+            The display name of the level
+            </value>
+            <remarks>
+            <para>
+            The display name of the level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.LoggerKey">
+            <summary>
+            Used internally to accelerate hash table searches.
+            </summary>
+            <remarks>
+            <para>
+            Internal class used to improve performance of 
+            string keyed hashtables.
+            </para>
+            <para>
+            The hashcode of the string is cached for reuse.
+            The string is stored as an interned value.
+            When comparing two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> objects for equality 
+            the reference equality of the interned strings is compared.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.#ctor(System.String)">
+            <summary>
+            Construct key with string name
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> class 
+            with the specified name.
+            </para>
+            <para>
+            Stores the hashcode of the string and interns
+            the string key to optimize comparisons.
+            </para>
+            <note>
+            The Compact Framework 1.0 the <see cref="M:System.String.Intern(System.String)"/>
+            method does not work. On the Compact Framework
+            the string keys are not interned nor are they
+            compared by reference.
+            </note>
+            </remarks>
+            <param name="name">The name of the logger.</param>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.GetHashCode">
+            <summary>
+            Returns a hash code for the current instance.
+            </summary>
+            <returns>A hash code for the current instance.</returns>
+            <remarks>
+            <para>
+            Returns the cached hashcode.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.Equals(System.Object)">
+            <summary>
+            Determines whether two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> instances 
+            are equal.
+            </summary>
+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>.</param>
+            <returns>
+            <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>.
+            </returns>
+            <remarks>
+            <para>
+            Compares the references of the interned strings.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">
+            <summary>
+            Provision nodes are used where no logger instance has been specified
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> instances are used in the 
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> when there is no specified 
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> for that node.
+            </para>
+            <para>
+            A provision node holds a list of child loggers on behalf of
+            a logger that does not exist.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">
+            <summary>
+            Create a new provision node with child node
+            </summary>
+            <param name="log">A child logger to add to this node.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> class 
+            with the specified child logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.RootLogger">
+            <summary>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> sits at the root of the logger hierarchy tree. 
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> is a regular <see cref="T:log4net.Repository.Hierarchy.Logger"/> except 
+            that it provides several guarantees.
+            </para>
+            <para>
+            First, it cannot be assigned a <c>null</c>
+            level. Second, since the root logger cannot have a parent, the
+            <see cref="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel"/> property always returns the value of the
+            level field without walking the hierarchy.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.Core.Level)">
+            <summary>
+            Construct a <see cref="T:log4net.Repository.Hierarchy.RootLogger"/>
+            </summary>
+            <param name="level">The level to assign to the root logger.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> class with
+            the specified logging level.
+            </para>
+            <para>
+            The root logger names itself as "root". However, the root
+            logger cannot be retrieved by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.RootLogger.declaringType">
+            <summary>
+            The fully qualified type of the RootLogger class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel">
+            <summary>
+            Gets the assigned level value without walking the logger hierarchy.
+            </summary>
+            <value>The assigned level value without walking the logger hierarchy.</value>
+            <remarks>
+            <para>
+            Because the root logger cannot have a parent and its level
+            must not be <c>null</c> this property just returns the
+            value of <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">
+            <summary>
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> for the root logger.  
+            </summary>
+            <value>
+            The <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> of the root logger.
+            </value>
+            <remarks>
+            <para>
+            Setting the level of the root logger to a <c>null</c> reference
+            may have catastrophic results. We prevent this here.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator">
+            <summary>
+            Initializes the log4net environment using an XML DOM.
+            </summary>
+            <remarks>
+            <para>
+            Configures a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.#ctor(log4net.Repository.Hierarchy.Hierarchy)">
+            <summary>
+            Construct the configurator for a hierarchy
+            </summary>
+            <param name="hierarchy">The hierarchy to build.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator"/> class
+            with the specified <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.Configure(System.Xml.XmlElement)">
+            <summary>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </summary>
+            <param name="element">The root element to parse.</param>
+            <remarks>
+            <para>
+            Configure the hierarchy by parsing a DOM tree of XML elements.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">
+            <summary>
+            Parse appenders by IDREF.
+            </summary>
+            <param name="appenderRef">The appender ref element.</param>
+            <returns>The instance of the appender that the ref refers to.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return 
+            the appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">
+            <summary>
+            Parses an appender element.
+            </summary>
+            <param name="appenderElement">The appender element.</param>
+            <returns>The appender instance or <c>null</c> when parsing failed.</returns>
+            <remarks>
+            <para>
+            Parse an XML element that represents an appender and return
+            the appender instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLogger(System.Xml.XmlElement)">
+            <summary>
+            Parses a logger element.
+            </summary>
+            <param name="loggerElement">The logger element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRoot(System.Xml.XmlElement)">
+            <summary>
+            Parses the root logger element.
+            </summary>
+            <param name="rootElement">The root element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents the root logger.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses the children of a logger element.
+            </summary>
+            <param name="catElement">The category element.</param>
+            <param name="log">The logger instance.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse the child elements of a &lt;logger&gt; element.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement)">
+            <summary>
+            Parses an object renderer.
+            </summary>
+            <param name="element">The renderer element.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a renderer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
+            <summary>
+            Parses a level element.
+            </summary>
+            <param name="element">The level element.</param>
+            <param name="log">The logger object to set the level on.</param>
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
+            <remarks>
+            <para>
+            Parse an XML element that represents a level.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">
+            <summary>
+            Sets a parameter on an object.
+            </summary>
+            <param name="element">The parameter element.</param>
+            <param name="target">The object to set the parameter on.</param>
+            <remarks>
+            The parameter name must correspond to a writable property
+            on the object. The value of the parameter is a string,
+            therefore this function will attempt to set a string
+            property first. If unable to set a string property it
+            will inspect the property and its argument type. It will
+            attempt to call a static method called <c>Parse</c> on the
+            type of the property. This method will take a single
+            string argument and return a value that can be used to
+            set the property.
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.HasAttributesOrElements(System.Xml.XmlElement)">
+            <summary>
+            Test if an element has no attributes or child elements
+            </summary>
+            <param name="element">the element to inspect</param>
+            <returns><c>true</c> if the element has any attributes or child elements, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.IsTypeConstructible(System.Type)">
+            <summary>
+            Test if a <see cref="T:System.Type"/> is constructible with <c>Activator.CreateInstance</c>.
+            </summary>
+            <param name="type">the type to inspect</param>
+            <returns><c>true</c> if the type is creatable using a default constructor, <c>false</c> otherwise</returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindMethodInfo(System.Type,System.String)">
+            <summary>
+            Look for a method on the <paramref name="targetType"/> that matches the <paramref name="name"/> supplied
+            </summary>
+            <param name="targetType">the type that has the method</param>
+            <param name="name">the name of the method</param>
+            <returns>the method info found</returns>
+            <remarks>
+            <para>
+            The method must be a public instance method on the <paramref name="targetType"/>.
+            The method must be named <paramref name="name"/> or "Add" followed by <paramref name="name"/>.
+            The method must take a single parameter.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string value to a target type.
+            </summary>
+            <param name="type">The type of object to convert the string to.</param>
+            <param name="value">The string value to use as the value of the object.</param>
+            <returns>
+            <para>
+            An object of type <paramref name="type"/> with value <paramref name="value"/> or 
+            <c>null</c> when the conversion could not be performed.
+            </para>
+            </returns>
+        </member>
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement,System.Type,System.Type)">
+            <summary>
+            Creates an object as specified in XML.
+            </summary>
+            <param name="element">The XML element that contains the definition of the object.</param>
+            <param name="defaultTargetType">The object type to use if not explicitly specified.</param>
+            <param name="typeConstraint">The type that the returned object must be or must inherit from.</param>
+            <returns>The object or <c>null</c></returns>
+            <remarks>
+            <para>
+            Parse an XML element and create an object instance based on the configuration
+            data.
+            </para>
+            <para>
+            The type of the instance may be specified in the XML. If not
+            specified then the <paramref name="defaultTargetType"/> is used
+            as the type. However the type is specified it must support the
+            <paramref name="typeConstraint"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_appenderBag">
+            <summary>
+            key: appenderName, value: appender.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_hierarchy">
+            <summary>
+            The Hierarchy being configured.
+            </summary>
+        </member>
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.declaringType">
+            <summary>
+            The fully qualified type of the XmlHierarchyConfigurator class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.ConfigurationChangedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Repository.ConfigurationChangedEventArgs.#ctor(System.Collections.ICollection)">
+            <summary>
+            
+            </summary>
+            <param name="configurationMessages"></param>
+        </member>
+        <member name="P:log4net.Repository.ConfigurationChangedEventArgs.ConfigurationMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryShutdownEventHandler">
+            <summary>
+            Delegate used to handle logger repository shutdown event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository shutdown event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationResetEventHandler">
+            <summary>
+            Delegate used to handle logger repository configuration reset event notifications
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration reset.</param>
+            <param name="e">Empty event args</param>
+            <remarks>
+            <para>
+            Delegate used to handle logger repository configuration reset event notifications.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationChangedEventHandler">
+            <summary>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </summary>
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration changed.</param>
+            <param name="e">Empty event arguments.</param>
+            <remarks>
+            <para>
+            Delegate used to handle event notifications for logger repository configuration changes.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppDomainPatternConverter">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the name of the current AppDomain to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppDomainPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the name of the current AppDomain to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes name of the current AppDomain to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.AppSettingPatternConverter">
+            <summary>
+            AppSetting pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads appSettings from the application configuration file.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single appSettings value. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all appSettings will be dumped as a list of key value pairs.
+            </para>
+            <para>
+            A typical use is to specify a base directory for log files, e.g.
+            <example>
+            <![CDATA[
+            <log4net>
+               <appender name="MyAppender" type="log4net.Appender.RollingFileAppender">
+                 <file type="log4net.Util.PatternString" value="appsetting{LogDirectory}MyApp.log"/>
+                  ...
+              </appender>
+            </log4net>
+            ]]>
+            </example>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.AppSettingPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.DatePatternConverter">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time to the writer as a string.
+            </para>
+            <para>
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the formatting of the date. The following values are allowed:
+            <list type="definition">
+            	<listheader>
+            		<term>Option value</term>
+            		<description>Output</description>
+            	</listheader>
+            	<item>
+            		<term>ISO8601</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. 
+            		Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.
+            		</description>
+            	</item>
+            	<item>
+            		<term>DATE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>ABSOLUTE</term>
+            		<description>
+            		Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. 
+            		Formats using the <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.
+            		</description>
+            	</item>
+            	<item>
+            		<term>other</term>
+            		<description>
+            		Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. 
+            		This formatter passes the pattern string to the <see cref="T:System.DateTime"/> 
+            		<see cref="M:DateTime.ToString(string)"/> method.
+            		For details on valid patterns see 
+            		<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.
+            		</description>
+            	</item>
+            </list>
+            </para>
+            <para>
+            The date and time is in the local time zone and is rendered in that zone.
+            To output the time in Universal time see <see cref="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.m_dateFormatter">
+            <summary>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date and time passed is in the local time zone.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the DatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter">
+            <summary>
+            Write an <see cref="T:System.Environment.SpecialFolder"/> folder path to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an special path environment folder path to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output. <see cref="P:log4net.Util.PatternConverter.Option"/>
+            should be a value in the <see cref="T:System.Environment.SpecialFolder"/> enumeration.
+            </para>
+            </remarks>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an special path environment folder path to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the special path environment folder path to the output <paramref name="writer"/>.
+            The name of the special path environment folder path to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentFolderPathPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentPatternConverter">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <remarks>
+            <para>
+            Write an environment variable to the output writer.
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines 
+            the name of the variable to output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write an environment variable to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the environment variable to the output <paramref name="writer"/>.
+            The name of the environment variable to output must be set
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the EnvironmentPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.IdentityPatternConverter">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current thread identity to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.IdentityPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current thread identity to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes the current thread identity to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.IdentityPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the IdentityPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">
+            <summary>
+            Pattern converter for literal string instances in the pattern
+            </summary>
+            <remarks>
+            <para>
+            Writes the literal string value specified in the 
+            <see cref="P:log4net.Util.PatternConverter.Option"/> property to 
+            the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.SetNext(log4net.Util.PatternConverter)">
+            <summary>
+            Set the next converter in the chain
+            </summary>
+            <param name="pc">The next pattern converter in the chain</param>
+            <returns>The next pattern converter</returns>
+            <remarks>
+            <para>
+            Special case the building of the pattern converter chain
+            for <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> instances. Two adjacent
+            literals in the pattern can be represented by a single combined
+            pattern converter. This implementation detects when a 
+            <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> is added to the chain
+            after this converter and combines its value with this converter's
+            literal value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Format(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the literal to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            Override the formatting behavior to ignore the FormattingInfo
+            because we have a literal instead.
+            </para>
+            <para>
+            Writes the value of <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Convert this pattern into the rendered message
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, not set</param>
+            <remarks>
+            <para>
+            This method is not used.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.NewLinePatternConverter">
+            <summary>
+            Writes a newline to the output
+            </summary>
+            <remarks>
+            <para>
+            Writes the system dependent line terminator to the output.
+            This behavior can be overridden by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>:
+            </para>
+            <list type="definition">
+              <listheader>
+                <term>Option Value</term>
+                <description>Output</description>
+              </listheader>
+              <item>
+                <term>DOS</term>
+                <description>DOS or Windows line terminator <c>"\r\n"</c></description>
+              </item>
+              <item>
+                <term>UNIX</term>
+                <description>UNIX line terminator <c>"\n"</c></description>
+              </item>
+            </list>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.ProcessIdPatternConverter">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current process ID to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current process ID to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current process ID to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the ProcessIdPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.PropertyPatternConverter">
+            <summary>
+            Property pattern converter
+            </summary>
+            <remarks>
+            <para>
+            This pattern converter reads the thread and global properties.
+            The thread properties take priority over global properties.
+            See <see cref="P:log4net.ThreadContext.Properties"/> for details of the 
+            thread properties. See <see cref="P:log4net.GlobalContext.Properties"/> for
+            details of the global properties.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to
+            lookup a single property. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified
+            then all properties will be dumped as a list of key value pairs.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.PropertyPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the property value to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Writes out the value of a named property. The property name
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            property.
+            </para>
+            <para>
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>
+            then all the properties are written as key value pairs.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.RandomStringPatternConverter">
+            <summary>
+            A Pattern converter that generates a string of random characters
+            </summary>
+            <remarks>
+            <para>
+            The converter generates a string of random characters. By default
+            the string is length 4. This can be changed by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>
+            to the string value of the length required.
+            </para>
+            <para>
+            The random characters in the string are limited to uppercase letters
+            and numbers only.
+            </para>
+            <para>
+            The random number generator used by this class is not cryptographically secure.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.s_random">
+            <summary>
+            Shared random number generator
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.m_length">
+            <summary>
+            Length of random string to generate. Default length 4.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions">
+            <summary>
+            Initialize the converter options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write a randoim string to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write a randoim string to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the RandomStringPatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UserNamePatternConverter">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <remarks>
+            <para>
+            Write the current threads username to the output writer
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UserNamePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current threads username to the output
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Write the current threads username to the output <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UserNamePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UserNamePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter">
+            <summary>
+            Write the UTC date time to the output
+            </summary>
+            <remarks>
+            <para>
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format 
+            the current date and time in Universal time.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/> for details on the date pattern syntax.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.PatternStringConverters.UtcDatePatternConverter.Convert(System.IO.TextWriter,System.Object)">
+            <summary>
+            Write the current date and time to the output
+            </summary>
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
+            <param name="state">null, state is not set</param>
+            <remarks>
+            <para>
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>
+            for it to render it to the writer.
+            </para>
+            <para>
+            The date is in Universal time when it is rendered.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>
+        </member>
+        <member name="F:log4net.Util.PatternStringConverters.UtcDatePatternConverter.declaringType">
+            <summary>
+            The fully qualified type of the UtcDatePatternConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.BooleanConverter">
+            <summary>
+            Type converter for Boolean.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <c>bool</c> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">
+            <summary>
+            Convert the source object to the type supported by this object
+            </summary>
+            <param name="source">the object to convert</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            <summary>
+            Exception base type for conversion errors.
+            </summary>
+            <remarks>
+            <para>
+            This type extends <see cref="T:System.ApplicationException"/>. It
+            does not add any new functionality but does differentiate the
+            type of exception being thrown.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">A message to include with the exception.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
+            with the specified message and inner exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">
+            <summary>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </summary>
+            <param name="destinationType">The conversion destination type.</param>
+            <param name="sourceValue">The value to convert.</param>
+            <param name="innerException">A nested exception to include.</param>
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.ConverterRegistry">
+            <summary>
+            Register of type converters for specific types.
+            </summary>
+            <remarks>
+            <para>
+            Maintains a registry of type converters used to convert between
+            types.
+            </para>
+            <para>
+            Use the <see cref="M:AddConverter(Type, object)"/> and 
+            <see cref="M:AddConverter(Type, Type)"/> methods to register new converters.
+            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
+            lookup appropriate converters to use.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConverterRegistry"/> class.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#cctor">
+            <summary>
+            Static constructor.
+            </summary>
+            <remarks>
+            <para>
+            This constructor defines the intrinsic type converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Object)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converter">The type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter instance for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Type)">
+            <summary>
+            Adds a converter for a specific type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <param name="converterType">The type of the type converter to use to convert to the destination type.</param>
+            <remarks>
+            <para>
+            Adds a converter <see cref="T:System.Type"/> for a specific type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="sourceType">The type being converted from.</param>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)">
+            <summary>
+            Gets the type converter to use to convert values to the destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            Gets the type converter to use to convert values to the destination type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConverterFromAttribute(System.Type)">
+            <summary>
+            Lookups the type converter to use as specified by the attributes on the 
+            destination type.
+            </summary>
+            <param name="destinationType">The type being converted to.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.CreateConverterInstance(System.Type)">
+            <summary>
+            Creates the instance of the type converter.
+            </summary>
+            <param name="converterType">The type of the type converter.</param>
+            <returns>
+            The type converter instance to use for type conversions or <c>null</c> 
+            if no type converter is found.
+            </returns>
+            <remarks>
+            <para>
+            The type specified for the type converter must implement 
+            the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> or <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces 
+            and must have a public default (no argument) constructor.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.declaringType">
+            <summary>
+            The fully qualified type of the ConverterRegistry class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.s_type2converter">
+            <summary>
+            Mapping from <see cref="T:System.Type"/> to type converter.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.EncodingConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an encoding</param>
+            <returns>the encoding</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to 
+            convert the <see cref="T:System.String"/> argument to an <see cref="T:System.Text.Encoding"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IConvertTo">
+            <summary>
+            Interface supported by type converters
+            </summary>
+            <remarks>
+            <para>
+            This interface supports conversion from a single type to arbitrary types.
+            See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.CanConvertTo(System.Type)">
+            <summary>
+            Returns whether this converter can convert the object to the specified type
+            </summary>
+            <param name="targetType">A Type that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Test if the type supported by this converter can be converted to the
+            <paramref name="targetType"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Converts the <paramref name="source"/> (which must be of the type supported
+            by this converter) to the <paramref name="targetType"/> specified..
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.IPAddressConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to an IPAddress</param>
+            <returns>the IPAddress</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:System.Net.IPAddress.Parse(System.String)"/> method to convert the
+            <see cref="T:System.String"/> argument to an <see cref="T:System.Net.IPAddress"/>.
+            If that fails then the string is resolved as a DNS hostname.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.IPAddressConverter.validIpAddressChars">
+            <summary>
+            Valid characters in an IPv4 or IPv6 address string. (Does not support subnets)
+            </summary>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternLayoutConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> 
+            of the <see cref="T:log4net.Layout.PatternLayout"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternLayout</param>
+            <returns>the PatternLayout</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Layout.PatternLayout"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.PatternStringConverter">
+            <summary>
+            Convert between string and <see cref="T:log4net.Util.PatternString"/>
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:log4net.Util.PatternString"/> type, 
+            and from a <see cref="T:log4net.Util.PatternString"/> type to a string.
+            </para>
+            <para>
+            The string is used as the <see cref="P:log4net.Util.PatternString.ConversionPattern"/> 
+            of the <see cref="T:log4net.Util.PatternString"/>.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)">
+            <summary>
+            Can the target type be converted to the type supported by this object
+            </summary>
+            <param name="targetType">A <see cref="T:System.Type"/> that represents the type you want to convert to</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="targetType"/> is
+            assignable from a <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertTo(System.Object,System.Type)">
+            <summary>
+            Converts the given value object to the specified type, using the arguments
+            </summary>
+            <param name="source">the object to convert</param>
+            <param name="targetType">The Type to convert the value parameter to</param>
+            <returns>the converted object</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:PatternString.Format()"/> method to convert the
+            <see cref="T:log4net.Util.PatternString"/> argument to a <see cref="T:System.String"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            <paramref name="targetType"/>. To check for this condition use the 
+            <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)"/> method.
+            </exception>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a PatternString</param>
+            <returns>the PatternString</returns>
+            <remarks>
+            <para>
+            Creates and returns a new <see cref="T:log4net.Util.PatternString"/> using
+            the <paramref name="source"/> <see cref="T:System.String"/> as the
+            <see cref="P:log4net.Util.PatternString.ConversionPattern"/>.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverter">
+            <summary>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </summary>
+            <remarks>
+            <para>
+            Supports conversion from string to <see cref="T:System.Type"/> type.
+            </para>
+            </remarks>
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)">
+            <summary>
+            Can the source type be converted to the type supported by this object
+            </summary>
+            <param name="sourceType">the type to convert</param>
+            <returns>true if the conversion is possible</returns>
+            <remarks>
+            <para>
+            Returns <c>true</c> if the <paramref name="sourceType"/> is
+            the <see cref="T:System.String"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.ConvertFrom(System.Object)">
+            <summary>
+            Overrides the ConvertFrom method of IConvertFrom.
+            </summary>
+            <param name="source">the object to convert to a Type</param>
+            <returns>the Type</returns>
+            <remarks>
+            <para>
+            Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Type"/>.
+            Additional effort is made to locate partially specified types
+            by searching the loaded assemblies.
+            </para>
+            </remarks>
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
+            The <paramref name="source"/> object cannot be converted to the
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)"/>
+            method.
+            </exception>
+        </member>
+        <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">
+            <summary>
+            Attribute used to associate a type converter
+            </summary>
+            <remarks>
+            <para>
+            Class and Interface level attribute that specifies a type converter
+            to use with the associated type.
+            </para>
+            <para>
+            To associate a type converter with a target type apply a
+            <c>TypeConverterAttribute</c> to the target type. Specify the
+            type of the type converter on the attribute.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">
+            <summary>
+            The string type name of the type converter
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">
+            <summary>
+            Create a new type converter attribute for the specified type name
+            </summary>
+            <param name="typeName">The string type name of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">
+            <summary>
+            Create a new type converter attribute for the specified type
+            </summary>
+            <param name="converterType">The type of the type converter</param>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">
+            <summary>
+            The string type name of the type converter 
+            </summary>
+            <value>
+            The string type name of the type converter 
+            </value>
+            <remarks>
+            <para>
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> 
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.AppenderAttachedImpl">
+            <summary>
+            A straightforward implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.
+            </summary>
+            <remarks>
+            <para>
+            This is the default implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/>
+            interface. Implementors of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
+            should aggregate an instance of this type.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.AppenderAttachedImpl"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent)">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvent">The event being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent[])">
+            <summary>
+            Append on on all attached appenders.
+            </summary>
+            <param name="loggingEvents">The array of events being logged.</param>
+            <returns>The number of appenders called.</returns>
+            <remarks>
+            <para>
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all 
+            attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.CallAppend(log4net.Appender.IAppender,log4net.Core.LoggingEvent[])">
+            <summary>
+            Calls the DoAppende method on the <see cref="T:log4net.Appender.IAppender"/> with 
+            the <see cref="T:log4net.Core.LoggingEvent"/> objects supplied.
+            </summary>
+            <param name="appender">The appender</param>
+            <param name="loggingEvents">The events</param>
+            <remarks>
+            <para>
+            If the <paramref name="appender"/> supports the <see cref="T:log4net.Appender.IBulkAppender"/>
+            interface then the <paramref name="loggingEvents"/> will be passed 
+            through using that interface. Otherwise the <see cref="T:log4net.Core.LoggingEvent"/>
+            objects in the array will be passed one at a time.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">
+            <summary>
+            Attaches an appender.
+            </summary>
+            <param name="newAppender">The appender to add.</param>
+            <remarks>
+            <para>
+            If the appender is already in the list it won't be added again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.GetAppender(System.String)">
+            <summary>
+            Gets an attached appender with the specified name.
+            </summary>
+            <param name="name">The name of the appender to get.</param>
+            <returns>
+            The appender with the name specified, or <c>null</c> if no appender with the
+            specified name is found.
+            </returns>
+            <remarks>
+            <para>
+            Lookup an attached appender by name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAllAppenders">
+            <summary>
+            Removes all attached appenders.
+            </summary>
+            <remarks>
+            <para>
+            Removes and closes all attached appenders
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">
+            <summary>
+            Removes the specified appender from the list of attached appenders.
+            </summary>
+            <param name="appender">The appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(System.String)">
+            <summary>
+            Removes the appender with the specified name from the list of appenders.
+            </summary>
+            <param name="name">The name of the appender to remove.</param>
+            <returns>The appender removed from the list</returns>
+            <remarks>
+            <para>
+            The appender removed is not closed.
+            If you are discarding the appender you must call
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderList">
+            <summary>
+            List of appenders
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderArray">
+            <summary>
+            Array of appenders, used to cache the m_appenderList
+            </summary>
+        </member>
+        <member name="F:log4net.Util.AppenderAttachedImpl.declaringType">
+            <summary>
+            The fully qualified type of the AppenderAttachedImpl class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.AppenderAttachedImpl.Appenders">
+            <summary>
+            Gets all attached appenders.
+            </summary>
+            <returns>
+            A collection of attached appenders, or <c>null</c> if there
+            are no attached appenders.
+            </returns>
+            <remarks>
+            <para>
+            The read only collection of all currently attached appenders.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CompositeProperties">
+            <summary>
+            This class aggregates several PropertiesDictionary collections together.
+            </summary>
+            <remarks>
+            <para>
+            Provides a dictionary style lookup over an ordered list of
+            <see cref="T:log4net.Util.PropertiesDictionary"/> collections.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CompositeProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Add(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Add a Properties Dictionary to this composite collection
+            </summary>
+            <param name="properties">the properties to add</param>
+            <remarks>
+            <para>
+            Properties dictionaries added first take precedence over dictionaries added
+            later.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CompositeProperties.Flatten">
+            <summary>
+            Flatten this composite collection into a single properties dictionary
+            </summary>
+            <returns>the flattened dictionary</returns>
+            <remarks>
+            <para>
+            Reduces the collection of ordered dictionaries to a single dictionary
+            containing the resultant values for the keys.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CompositeProperties.Item(System.String)">
+            <summary>
+            Gets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Looks up the value for the <paramref name="key"/> specified.
+            The <see cref="T:log4net.Util.PropertiesDictionary"/> collections are searched
+            in the order in which they were added to this collection. The value
+            returned is the value held by the first collection that contains
+            the specified key.
+            </para>
+            <para>
+            If none of the collections contain the specified key then
+            <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ContextPropertiesBase">
+            <summary>
+            Base class for Context Properties implementations
+            </summary>
+            <remarks>
+            <para>
+            This class defines a basic property get set accessor
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ConverterInfo">
+            <summary>
+            Wrapper class used to map converter names to converter types
+            </summary>
+            <remarks>
+            <para>
+            Pattern converter info class used during configuration by custom
+            PatternString and PatternLayer converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.#ctor">
+            <summary>
+            default constructor
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ConverterInfo.AddProperty(log4net.Util.PropertyEntry)">
+            <summary>
+            
+            </summary>
+            <param name="entry"></param>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Name">
+            <summary>
+            Gets or sets the name of the conversion pattern
+            </summary>
+            <remarks>
+            <para>
+            The name of the pattern in the format string
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Type">
+            <summary>
+            Gets or sets the type of the converter
+            </summary>
+            <remarks>
+            <para>
+            The value specified must extend the 
+            <see cref="T:log4net.Util.PatternConverter"/> type.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ConverterInfo.Properties">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.CountingQuietTextWriter">
+            <summary>
+            Subclass of <see cref="T:log4net.Util.QuietTextWriter"/> that maintains a count of 
+            the number of bytes written.
+            </summary>
+            <remarks>
+            <para>
+            This writer counts the number of bytes written.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.QuietTextWriter">
+            <summary>
+            <see cref="T:System.IO.TextWriter"/> that does not leak exceptions
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:log4net.Util.QuietTextWriter"/> does not throw exceptions when things go wrong. 
+            Instead, it delegates error handling to its <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.TextWriterAdapter">
+            <summary>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <remarks>
+            <para>
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.TextWriterAdapter.m_writer">
+            <summary>
+            The writer to forward messages to
+            </summary>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
+            messages to a <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Close">
+            <summary>
+            Closes the writer and releases any system resources associated with the writer
+            </summary>
+            <remarks>
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">
+            <summary>
+            Dispose this writer
+            </summary>
+            <param name="disposing">flag indicating if we are being disposed</param>
+            <remarks>
+            <para>
+            Dispose this writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Flush">
+            <summary>
+            Flushes any buffered output
+            </summary>
+            <remarks>
+            <para>
+            Clears all buffers for the writer and causes any buffered data to be written 
+            to the underlying device
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">
+            <summary>
+            Writes a character to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a character to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a character buffer to the wrapped TextWriter
+            </summary>
+            <param name="buffer">the data buffer</param>
+            <param name="index">the start index</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a character buffer to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">
+            <summary>
+            Writes a string to the wrapped TextWriter
+            </summary>
+            <param name="value">the value to write to the TextWriter</param>
+            <remarks>
+            <para>
+            Writes a string to the wrapped TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Writer">
+            <summary>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </summary>
+            <value>
+            The underlying <see cref="T:System.IO.TextWriter"/>.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.Encoding">
+            <summary>
+            The Encoding in which the output is written
+            </summary>
+            <value>
+            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>
+            </value>
+            <remarks>
+            <para>
+            The Encoding in which the output is written
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">
+            <summary>
+            Gets an object that controls formatting
+            </summary>
+            <value>
+            The format provider
+            </value>
+            <remarks>
+            <para>
+            Gets an object that controls formatting
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.TextWriterAdapter.NewLine">
+            <summary>
+            Gets or sets the line terminator string used by the TextWriter
+            </summary>
+            <value>
+            The line terminator to use
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the line terminator string used by the TextWriter
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <param name="errorHandler">the error handler to report error to</param>
+            <remarks>
+            <para>
+            Create a new QuietTextWriter using a writer and error handler
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Writes a character to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Writes a buffer to the underlying writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output.
+            </summary>
+            <param name="value">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Writes a string to the output.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.QuietTextWriter.Close">
+            <summary>
+            Closes the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Closes the underlying output writer.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_errorHandler">
+            <summary>
+            The error handler instance to pass all errors to
+            </summary>
+        </member>
+        <member name="F:log4net.Util.QuietTextWriter.m_closed">
+            <summary>
+            Flag to indicate if this writer is closed
+            </summary>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.ErrorHandler">
+            <summary>
+            Gets or sets the error handler that all errors are passed to.
+            </summary>
+            <value>
+            The error handler that all errors are passed to.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the error handler that all errors are passed to.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.QuietTextWriter.Closed">
+            <summary>
+            Gets a value indicating whether this writer is closed.
+            </summary>
+            <value>
+            <c>true</c> if this writer is closed, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            Gets a value indicating whether this writer is closed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to actually write to.</param>
+            <param name="errorHandler">The <see cref="T:log4net.Core.IErrorHandler"/> to report errors to.</param>
+            <remarks>
+            <para>
+            Creates a new instance of the <see cref="T:log4net.Util.CountingQuietTextWriter"/> class 
+            with the specified <see cref="T:System.IO.TextWriter"/> and <see cref="T:log4net.Core.IErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char)">
+            <summary>
+            Writes a character to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="value">the char to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">
+            <summary>
+            Writes a buffer to the underlying writer and counts the number of bytes written.
+            </summary>
+            <param name="buffer">the buffer to write</param>
+            <param name="index">the start index to write from</param>
+            <param name="count">the number of characters to write</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.String)">
+            <summary>
+            Writes a string to the output and counts the number of bytes written.
+            </summary>
+            <param name="str">The string data to write to the output.</param>
+            <remarks>
+            <para>
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts
+            the number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.CountingQuietTextWriter.m_countBytes">
+            <summary>
+            Total number of bytes written.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.CountingQuietTextWriter.Count">
+            <summary>
+            Gets or sets the total number of bytes written.
+            </summary>
+            <value>
+            The total number of bytes written.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the total number of bytes written.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.CyclicBuffer">
+            <summary>
+            A fixed size rolling buffer of logging events.
+            </summary>
+            <remarks>
+            <para>
+            An array backed fixed size leaky bucket.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="maxSize">The maximum number of logging events in the buffer.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with 
+            the specified maximum number of buffered logging events.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">
+            <summary>
+            Appends a <paramref name="loggingEvent"/> to the buffer.
+            </summary>
+            <param name="loggingEvent">The event to append to the buffer.</param>
+            <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>
+            <remarks>
+            <para>
+            Append an event to the buffer. If the buffer still contains free space then
+            <c>null</c> is returned. If the buffer is full then an event will be dropped
+            to make space for the new event, the event dropped is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopOldest">
+            <summary>
+            Get and remove the oldest event in the buffer.
+            </summary>
+            <returns>The oldest logging event in the buffer</returns>
+            <remarks>
+            <para>
+            Gets the oldest (first) logging event in the buffer and removes it 
+            from the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.PopAll">
+            <summary>
+            Pops all the logging events from the buffer into an array.
+            </summary>
+            <returns>An array of all the logging events in the buffer.</returns>
+            <remarks>
+            <para>
+            Get all the events in the buffer and clear the buffer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.CyclicBuffer.Clear">
+            <summary>
+            Clear the buffer
+            </summary>
+            <remarks>
+            <para>
+            Clear the buffer of all events. The events in the buffer are lost.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">
+            <summary>
+            Gets the <paramref name="i"/>th oldest event currently in the buffer.
+            </summary>
+            <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>
+            <remarks>
+            <para>
+            If <paramref name="i"/> is outside the range 0 to the number of events
+            currently in the buffer, then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.MaxSize">
+            <summary>
+            Gets the maximum size of the buffer.
+            </summary>
+            <value>The maximum size of the buffer.</value>
+            <remarks>
+            <para>
+            Gets the maximum size of the buffer
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.CyclicBuffer.Length">
+            <summary>
+            Gets the number of logging events in the buffer.
+            </summary>
+            <value>The number of logging events in the buffer.</value>
+            <remarks>
+            <para>
+            This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>
+            (inclusive).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyCollection">
+            <summary>
+            An always empty <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.ICollection"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyCollection"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyCollection.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.EmptyCollection.s_instance">
+            <summary>
+            The singleton instance of the empty collection.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Instance">
+            <summary>
+            Gets the singleton instance of the empty collection.
+            </summary>
+            <returns>The singleton instance of the empty collection.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the empty collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyCollection.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyCollection.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyCollection.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.EmptyDictionary">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionary"/>
+            interface that always represents an empty collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyDictionary"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.CopyTo(System.Array,System.Int32)">
+            <summary>
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an 
+            <see cref="T:System.Array"/>, starting at a particular Array index.
+            </summary>
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> 
+            that is the destination of the elements copied from 
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based 
+            indexing.</param>
+            <param name="index">The zero-based index in array at which 
+            copying begins.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values are copied into the array.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Add(System.Object,System.Object)">
+            <summary>
+            Adds an element with the provided key and value to the 
+            <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>
+            <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>
+            <remarks>
+            <para>
+            As the collection is empty no new values can be added. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Clear">
+            <summary>
+            Removes all elements from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Contains(System.Object)">
+            <summary>
+            Determines whether the <see cref="T:log4net.Util.EmptyDictionary"/> contains an element 
+            with the specified key.
+            </summary>
+            <param name="key">The key to locate in the <see cref="T:log4net.Util.EmptyDictionary"/>.</param>
+            <returns><c>false</c></returns>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="M:log4net.Util.EmptyDictionary.Contains(System.Object)"/> method always returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.GetEnumerator">
+            <summary>
+            Returns an enumerator that can iterate through a collection.
+            </summary>
+            <returns>
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to 
+            iterate through the collection.
+            </returns>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.EmptyDictionary.Remove(System.Object)">
+            <summary>
+            Removes the element with the specified key from the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <param name="key">The key of the element to remove.</param>
+            <remarks>
+            <para>
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>
+            is thrown if this method is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="F:log4net.Util.EmptyDictionary.s_instance">
+            <summary>
+            The singleton instance of the empty dictionary.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsSynchronized">
+            <summary>
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
+            </summary>
+            <value>
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
+            </value>
+            <remarks>
+            <para>
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <b>true</b>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Count">
+            <summary>
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>
+            </summary>
+            <value>
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty the <see cref="P:log4net.Util.EmptyDictionary.Count"/> is always <c>0</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.SyncRoot">
+            <summary>
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </summary>
+            <value>
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
+            </value>
+            <remarks>
+            <para>
+            As the collection is empty and thread safe and synchronized this instance is also
+            the <see cref="P:log4net.Util.EmptyDictionary.SyncRoot"/> object.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsFixedSize">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> has a fixed size.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsFixedSize"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.IsReadOnly">
+            <summary>
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> is read-only.
+            </summary>
+            <value><c>true</c></value>
+            <remarks>
+            <para>
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsReadOnly"/> always returns <c>true</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Keys">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Values">
+            <summary>
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.
+            </summary>
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>
+            <remarks>
+            <para>
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.EmptyDictionary.Item(System.Object)">
+            <summary>
+            Gets or sets the element with the specified key.
+            </summary>
+            <param name="key">The key of the element to get or set.</param>
+            <value><c>null</c></value>
+            <remarks>
+            <para>
+            As the collection is empty no values can be looked up or stored. 
+            If the index getter is called then <c>null</c> is returned.
+            A <see cref="T:System.InvalidOperationException"/> is thrown if the setter is called.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>
+        </member>
+        <member name="T:log4net.Util.FormattingInfo">
+            <summary>
+            Contain the information obtained when parsing formatting modifiers 
+            in conversion modifiers.
+            </summary>
+            <remarks>
+            <para>
+            Holds the formatting information extracted from the format string by
+            the <see cref="T:log4net.Util.PatternParser"/>. This is used by the <see cref="T:log4net.Util.PatternConverter"/>
+            objects when rendering the output.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor">
+            <summary>
+            Defaut Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.FormattingInfo.#ctor(System.Int32,System.Int32,System.Boolean)">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class
+            with the specified parameters.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Min">
+            <summary>
+            Gets or sets the minimum value.
+            </summary>
+            <value>
+            The minimum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the minimum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.Max">
+            <summary>
+            Gets or sets the maximum value.
+            </summary>
+            <value>
+            The maximum value.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the maximum value.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.FormattingInfo.LeftAlign">
+            <summary>
+            Gets or sets a flag indicating whether left align is enabled
+            or not.
+            </summary>
+            <value>
+            A flag indicating whether left align is enabled or not.
+            </value>
+            <remarks>
+            <para>
+            Gets or sets a flag indicating whether left align is enabled or not.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.GlobalContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.GlobalContext"/>
+            </summary>
+            <remarks>
+            <para>
+            This class implements a properties collection that is thread safe and supports both
+            storing properties and capturing a read only copy of the current propertied.
+            </para>
+            <para>
+            This class is optimized to the scenario where the properties are read frequently
+            and are modified infrequently.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_readOnlyProperties">
+            <summary>
+            The read only copy of the properties.
+            </summary>
+            <remarks>
+            <para>
+            This variable is declared <c>volatile</c> to prevent the compiler and JIT from
+            reordering reads and writes of this thread performed on different threads.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.GlobalContextProperties.m_syncRoot">
+            <summary>
+            Lock object used to synchronize updates within this instance
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.GlobalContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property from the global context
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Removing an entry from the global context properties is relatively expensive compared
+            with reading a value. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.Clear">
+            <summary>
+            Clear the global context properties
+            </summary>
+        </member>
+        <member name="M:log4net.Util.GlobalContextProperties.GetReadOnlyProperties">
+            <summary>
+            Get a readonly immutable copy of the properties
+            </summary>
+            <returns>the current global context properties</returns>
+            <remarks>
+            <para>
+            This implementation is fast because the GlobalContextProperties class
+            stores a readonly copy of the properties.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.GlobalContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Reading the value for a key is faster than setting the value.
+            When the value is written a new read only copy of 
+            the properties is created.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ILogExtensions">
+            <summary>
+            The static class ILogExtensions contains a set of widely used
+            methods that ease the interaction with the ILog interface implementations.
+            </summary>
+            <remarks>
+            <para>
+            This class contains methods for logging at different levels and checks the
+            properties for determining if those logging levels are enabled in the current
+            configuration.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            using log4net.Util;
+            
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.InfoExt("Application Start");
+            log.DebugExt("This is a debug message");
+            </code>
+            </example>
+        </member>
+        <member name="F:log4net.Util.ILogExtensions.declaringType">
+            <summary>
+            The fully qualified type of the Logger class.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>INFO</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>INFO</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>WARN</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>WARN</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>ERROR</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>ERROR</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object})">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation.  If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (retrieved by invocation of the provided callback) to a 
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
+            It then proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="callback">The lambda expression that gets the object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)">
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads> //TODO
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <remarks>
+            <para>
+            This method first checks if this logger is <c>FATAL</c>
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>
+            implementation. If this logger is <c>FATAL</c> enabled, then it converts 
+            the message object (passed as parameter) to a string by invoking the appropriate
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then 
+            proceeds to call all the registered appenders in this logger 
+            and also higher in the hierarchy depending on the value of 
+            the additivity flag.
+            </para>
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> 
+            to this method will print the name of the <see cref="T:System.Exception"/> 
+            but no stack trace. To print a stack trace use the 
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/> form instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)">
+            <summary>
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
+            the stack trace of the <see cref="T:System.Exception"/> passed
+            as a parameter.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="message">The message object to log.</param>
+            <param name="exception">The exception to log, including its stack trace.</param>
+            <remarks>
+            <para>
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="args">An Object array containing zero or more objects to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">
+            <summary>
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
+            </summary>
+            <param name="logger">The logger on which the message is logged.</param>
+            <param name="format">A String containing zero or more format items</param>
+            <param name="arg0">An Object to format</param>
+            <param name="arg1">An Object to format</param>
+            <param name="arg2">An Object to format</param>
+            <remarks>
+            <para>
+            The message is formatted using the <c>String.Format</c> method. See
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
+            of the formatting.
+            </para>
+            <para>
+            This method does not take an <see cref="T:System.Exception"/> object to include in the
+            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)"/>
+            methods instead.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
+        </member>
+        <member name="T:log4net.Util.LevelMapping">
+            <summary>
+            Manages a mapping from levels to <see cref="T:log4net.Util.LevelMappingEntry"/>
+            </summary>
+            <remarks>
+            <para>
+            Manages an ordered mapping from <see cref="T:log4net.Core.Level"/> instances 
+            to <see cref="T:log4net.Util.LevelMappingEntry"/> subclasses.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialise a new instance of <see cref="T:log4net.Util.LevelMapping"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Add(log4net.Util.LevelMappingEntry)">
+            <summary>
+            Add a <see cref="T:log4net.Util.LevelMappingEntry"/> to this mapping
+            </summary>
+            <param name="entry">the entry to add</param>
+            <remarks>
+            <para>
+            If a <see cref="T:log4net.Util.LevelMappingEntry"/> has previously been added
+            for the same <see cref="T:log4net.Core.Level"/> then that entry will be 
+            overwritten.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.Lookup(log4net.Core.Level)">
+            <summary>
+            Lookup the mapping for the specified level
+            </summary>
+            <param name="level">the level to lookup</param>
+            <returns>the <see cref="T:log4net.Util.LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
+            <remarks>
+            <para>
+            Lookup the value for the specified level. Finds the nearest
+            mapping value for the level that is equal to or less than the
+            <paramref name="level"/> specified.
+            </para>
+            <para>
+            If no mapping could be found then <c>null</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LevelMapping.ActivateOptions">
+            <summary>
+            Initialize options
+            </summary>
+            <remarks>
+            <para>
+            Caches the sorted list of <see cref="T:log4net.Util.LevelMappingEntry"/> in an array
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            <para>
+            This class stores its properties in a slot on the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> named
+            <c>log4net.Util.LogicalThreadContextProperties</c>.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.m_disabled">
+            <summary>
+            Flag used to disable this context if we don't have permission to access the CallContext.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the value for the specified <paramref name="key"/> from the context.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Clear">
+            <summary>
+            Clear all the context properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all the context properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the PropertiesDictionary stored in the LocalDataStoreSlot for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doings so.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetLogicalProperties">
+            <summary>
+            Gets the call context get data.
+            </summary>
+            <returns>The peroperties dictionary stored in the call context</returns>
+            <remarks>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.GetData(System.String)"/> has a
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextProperties.SetLogicalProperties(log4net.Util.PropertiesDictionary)">
+            <summary>
+            Sets the call context data.
+            </summary>
+            <param name="properties">The properties.</param>
+            <remarks>
+            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
+            security link demand, therfore we must put the method call in a seperate method
+            that we can wrap in an exception handler.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextProperties.declaringType">
+            <summary>
+            The fully qualified type of the LogicalThreadContextProperties class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Get or set the property value for the <paramref name="key"/> specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.TwoArgAction`2">
+            <summary>
+            Delegate type used for LogicalThreadContextStack's callbacks.
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_propertyKey">
+            <summary>
+            The name of this <see cref="T:log4net.Util.LogicalThreadContextStack"/> within the
+            <see cref="T:log4net.Util.LogicalThreadContextProperties"/>.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.m_registerNew">
+            <summary>
+            The callback used to let the <see cref="T:log4net.Util.LogicalThreadContextStacks"/> register a
+            new instance of a <see cref="T:log4net.Util.LogicalThreadContextStack"/>.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.#ctor(System.String,log4net.Util.TwoArgAction{System.String,log4net.Util.LogicalThreadContextStack})">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this thread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.LogicalThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.LogicalThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.LogicalThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.LogicalThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.LogicalThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.m_logicalThreadContextStack">
+            <summary>
+            The outer LogicalThreadContextStack.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.#ctor(log4net.Util.LogicalThreadContextStack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="logicalThreadContextStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogicalThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.LogicalThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.LogicalThreadContextStacks.#ctor(log4net.Util.LogicalThreadContextProperties)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogicalThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogicalThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventHandler">
+            <summary>
+            
+            </summary>
+            <param name="source"></param>
+            <param name="e"></param>
+        </member>
+        <member name="T:log4net.Util.LogLog">
+            <summary>
+            Outputs log statements from within the log4net assembly.
+            </summary>
+            <remarks>
+            <para>
+            Log4net components cannot make log4net logging calls. However, it is
+            sometimes useful for the user to learn about what log4net is
+            doing.
+            </para>
+            <para>
+            All log4net internal debug calls go to the standard output stream
+            whereas internal error messages are sent to the standard error output 
+            stream.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.LogLog.ToString">
+            <summary>
+            Formats Prefix, Source, and Message in the same format as the value
+            sent to Console.Out and Trace.Write.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.LogLog.#ctor(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.LogLog"/> class. 
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.#cctor">
+            <summary>
+            Static constructor that initializes logging by reading 
+            settings from the application configuration file.
+            </summary>
+            <remarks>
+            <para>
+            The <c>log4net.Internal.Debug</c> application setting
+            controls internal debugging. This setting should be set
+            to <c>true</c> to enable debugging.
+            </para>
+            <para>
+            The <c>log4net.Internal.Quiet</c> application setting
+            suppresses all internal logging including error messages. 
+            This setting should be set to <c>true</c> to enable message
+            suppression.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.OnLogReceived(System.Type,System.String,System.String,System.Exception)">
+            <summary>
+            Raises the LogReceived event when an internal messages is received.
+            </summary>
+            <param name="source"></param>
+            <param name="prefix"></param>
+            <param name="message"></param>
+            <param name="exception"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source"></param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal debug messages to the 
+            standard output stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net: ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal warning messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal warning messages are prepended with 
+            the string "log4net:WARN ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            All internal error messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String,System.Exception)">
+            <summary>
+            Writes log4net internal error messages to the 
+            standard error stream.
+            </summary>
+            <param name="source">The Type that generated this message.</param>
+            <param name="message">The message to log.</param>
+            <param name="exception">An exception to log.</param>
+            <remarks>
+            <para>
+            All internal debug messages are prepended with 
+            the string "log4net:ERROR ".
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitOutLine(System.String)">
+            <summary>
+            Writes output to the standard output stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Out and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.LogLog.EmitErrorLine(System.String)">
+            <summary>
+            Writes output to the standard error stream.  
+            </summary>
+            <param name="message">The message to log.</param>
+            <remarks>
+            <para>
+            Writes to both Console.Error and System.Diagnostics.Trace.
+            Note that the System.Diagnostics.Trace is not supported
+            on the Compact Framework.
+            </para>
+            <para>
+            If the AppDomain is not configured with a config file then
+            the call to System.Diagnostics.Trace may fail. This is only
+            an issue if you are programmatically creating your own AppDomains.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_debugEnabled">
+            <summary>
+             Default debug level
+            </summary>
+        </member>
+        <member name="F:log4net.Util.LogLog.s_quietMode">
+            <summary>
+            In quietMode not even errors generate any output.
+            </summary>
+        </member>
+        <member name="E:log4net.Util.LogLog.LogReceived">
+            <summary>
+            The event raised when an internal message has been received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Source">
+            <summary>
+            The Type that generated the internal message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStamp">
+            <summary>
+            The DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.TimeStampUtc">
+            <summary>
+            The UTC DateTime stamp of when the internal message was received.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Prefix">
+            <summary>
+            A string indicating the severity of the internal message.
+            </summary>
+            <remarks>
+            "log4net: ", 
+            "log4net:ERROR ", 
+            "log4net:WARN "
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.Message">
+            <summary>
+            The internal log message.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.Exception">
+            <summary>
+            The Exception related to the message.
+            </summary>
+            <remarks>
+            Optional. Will be null if no Exception was passed.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.InternalDebugging">
+            <summary>
+            Gets or sets a value indicating whether log4net internal logging
+            is enabled or disabled.
+            </summary>
+            <value>
+            <c>true</c> if log4net internal logging is enabled, otherwise 
+            <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c>, internal debug level logging will be 
+            displayed.
+            </para>
+            <para>
+            This value can be set by setting the application setting 
+            <c>log4net.Internal.Debug</c> in the application configuration
+            file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. debugging is
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            <para>
+            The following example enables internal debugging using the 
+            application configuration file :
+            </para>
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Debug" value="true" />
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.QuietMode">
+            <summary>
+            Gets or sets a value indicating whether log4net should generate no output
+            from internal logging, not even for errors. 
+            </summary>
+            <value>
+            <c>true</c> if log4net should generate no output at all from internal 
+            logging, otherwise <c>false</c>.
+            </value>
+            <remarks>
+            <para>
+            When set to <c>true</c> will cause internal logging at all levels to be 
+            suppressed. This means that no warning or error reports will be logged. 
+            This option overrides the <see cref="P:log4net.Util.LogLog.InternalDebugging"/> setting and 
+            disables all debug also.
+            </para>
+            <para>This value can be set by setting the application setting
+            <c>log4net.Internal.Quiet</c> in the application configuration file.
+            </para>
+            <para>
+            The default value is <c>false</c>, i.e. internal logging is not
+            disabled.
+            </para>
+            </remarks>
+            <example>
+            The following example disables internal logging using the 
+            application configuration file :
+            <code lang="XML" escaped="true">
+            <configuration>
+            	<appSettings>
+            		<add key="log4net.Internal.Quiet" value="true"/>
+            	</appSettings>
+            </configuration>
+            </code>
+            </example>
+        </member>
+        <member name="P:log4net.Util.LogLog.EmitInternalMessages">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsDebugEnabled">
+            <summary>
+            Test if LogLog.Debug is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Debug is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Debug is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsWarnEnabled">
+            <summary>
+            Test if LogLog.Warn is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Warn is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Warn is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.LogLog.IsErrorEnabled">
+            <summary>
+            Test if LogLog.Error is enabled for output.
+            </summary>
+            <value>
+            <c>true</c> if Error is enabled
+            </value>
+            <remarks>
+            <para>
+            Test if LogLog.Error is enabled for output.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.LogLog.LogReceivedAdapter">
+            <summary>
+            Subscribes to the LogLog.LogReceived event and stores messages
+            to the supplied IList instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.#ctor(System.Collections.IList)">
+            <summary>
+            
+            </summary>
+            <param name="items"></param>
+        </member>
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.Dispose">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="P:log4net.Util.LogLog.LogReceivedAdapter.Items">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.LogReceivedEventArgs">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:log4net.Util.LogReceivedEventArgs.#ctor(log4net.Util.LogLog)">
+            <summary>
+            
+            </summary>
+            <param name="loglog"></param>
+        </member>
+        <member name="P:log4net.Util.LogReceivedEventArgs.LogLog">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:log4net.Util.NativeError">
+            <summary>
+            Represents a native error code and message.
+            </summary>
+            <remarks>
+            <para>
+            Represents a Win32 platform native error.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NativeError.#ctor(System.Int32,System.String)">
+            <summary>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </summary>
+            <param name="number">The number of the native error.</param>
+            <param name="message">The message of the native error.</param>
+            <remarks>
+            <para>
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified 
+            error number and message.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetLastError">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class for the last Windows error.
+            </summary>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the last windows error.
+            </returns>
+            <remarks>
+            <para>
+            The message for the <see cref="M:System.Runtime.InteropServices.Marshal.GetLastWin32Error"/> error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetError(System.Int32)">
+            <summary>
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class.
+            </summary>
+            <param name="number">the error number for the native error</param>
+            <returns>
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the specified 
+            error number.
+            </returns>
+            <remarks>
+            <para>
+            The message for the specified error number is lookup up using the 
+            native Win32 <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.GetErrorMessage(System.Int32)">
+            <summary>
+            Retrieves the message corresponding with a Win32 message identifier.
+            </summary>
+            <param name="messageId">Message identifier for the requested message.</param>
+            <returns>
+            The message corresponding with the specified message identifier.
+            </returns>
+            <remarks>
+            <para>
+            The message will be searched for in system message-table resource(s)
+            using the native <c>FormatMessage</c> function.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.ToString">
+            <summary>
+            Return error information string
+            </summary>
+            <returns>error information string</returns>
+            <remarks>
+            <para>
+            Return error information string
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NativeError.FormatMessage(System.Int32,System.IntPtr@,System.Int32,System.Int32,System.String@,System.Int32,System.IntPtr)">
+            <summary>
+            Formats a message string.
+            </summary>
+            <param name="dwFlags">Formatting options, and how to interpret the <paramref name="lpSource" /> parameter.</param>
+            <param name="lpSource">Location of the message definition.</param>
+            <param name="dwMessageId">Message identifier for the requested message.</param>
+            <param name="dwLanguageId">Language identifier for the requested message.</param>
+            <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>
+            <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>
+            <param name="Arguments">Pointer to an array of values that are used as insert values in the formatted message.</param>
+            <remarks>
+            <para>
+            The function requires a message definition as input. The message definition can come from a 
+            buffer passed into the function. It can come from a message table resource in an 
+            already-loaded module. Or the caller can ask the function to search the system's message 
+            table resource(s) for the message definition. The function finds the message definition 
+            in a message table resource based on a message identifier and a language identifier. 
+            The function copies the formatted message text to an output buffer, processing any embedded 
+            insert sequences if requested.
+            </para>
+            <para>
+            To prevent the usage of unsafe code, this stub does not support inserting values in the formatted message.
+            </para>
+            </remarks>
+            <returns>
+            <para>
+            If the function succeeds, the return value is the number of TCHARs stored in the output 
+            buffer, excluding the terminating null character.
+            </para>
+            <para>
+            If the function fails, the return value is zero. To get extended error information, 
+            call <see cref="M:Marshal.GetLastWin32Error()" />.
+            </para>
+            </returns>
+        </member>
+        <member name="P:log4net.Util.NativeError.Number">
+            <summary>
+            Gets the number of the native error.
+            </summary>
+            <value>
+            The number of the native error.
+            </value>
+            <remarks>
+            <para>
+            Gets the number of the native error.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NativeError.Message">
+            <summary>
+            Gets the message of the native error.
+            </summary>
+            <value>
+            The message of the native error.
+            </value>
+            <remarks>
+            <para>
+            </para>
+            Gets the message of the native error.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.NullDictionaryEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IDictionaryEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IDictionaryEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance.
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullDictionaryEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullDictionaryEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullDictionaryEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullDictionaryEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Instance">
+            <summary>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Key">
+            <summary>
+            Gets the current key from the enumerator.
+            </summary>
+            <remarks>
+            Throws an exception because the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>
+            never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Key"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Value">
+            <summary>
+            Gets the current value from the enumerator.
+            </summary>
+            <value>The current value from the enumerator.</value>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Value"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Entry">
+            <summary>
+            Gets the current entry from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current entry.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Entry"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullEnumerator">
+            <summary>
+            An always empty <see cref="T:System.Collections.IEnumerator"/>.
+            </summary>
+            <remarks>
+            <para>
+            A singleton implementation of the <see cref="T:System.Collections.IEnumerator"/> over a collection
+            that is empty and not modifiable.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.NullEnumerator"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to enforce the singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.MoveNext">
+            <summary>
+            Test if the enumerator can advance, if so advance
+            </summary>
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullEnumerator"/> cannot advance.</returns>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullEnumerator.MoveNext"/>
+            will always return <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullEnumerator.Reset">
+            <summary>
+            Resets the enumerator back to the start.
+            </summary>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullEnumerator.Reset"/> does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.NullEnumerator.s_instance">
+            <summary>
+            The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Instance">
+            <summary>
+            Get the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </summary>
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.</returns>
+            <remarks>
+            <para>
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.NullEnumerator.Current">
+            <summary>
+            Gets the current object from the enumerator.
+            </summary>
+            <remarks>
+            Throws an <see cref="T:System.InvalidOperationException"/> because the 
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.
+            </remarks>
+            <remarks>
+            <para>
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullEnumerator.Current"/>
+            will throw an <see cref="T:System.InvalidOperationException"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullEnumerator.Current"/> 
+            cannot be positioned over a valid location.</exception>
+        </member>
+        <member name="T:log4net.Util.NullSecurityContext">
+            <summary>
+            A SecurityContext used when a SecurityContext is not required
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Util.NullSecurityContext"/> is a no-op implementation of the
+            <see cref="T:log4net.Core.SecurityContext"/> base class. It is used where a <see cref="T:log4net.Core.SecurityContext"/>
+            is required but one has not been provided.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.NullSecurityContext.Instance">
+            <summary>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.#ctor">
+            <summary>
+            Private constructor
+            </summary>
+            <remarks>
+            <para>
+            Private constructor for singleton pattern.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.NullSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate this SecurityContext
+            </summary>
+            <param name="state">State supplied by the caller</param>
+            <returns><c>null</c></returns>
+            <remarks>
+            <para>
+            No impersonation is done and <c>null</c> is always returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OnlyOnceErrorHandler">
+            <summary>
+            Implements log4net's default error handling policy which consists 
+            of emitting a message for the first error in an appender and 
+            ignoring all subsequent errors.
+            </summary>
+            <remarks>
+            <para>
+            The error message is processed using the LogLog sub-system by default.
+            </para>
+            <para>
+            This policy aims at protecting an otherwise working application
+            from being flooded with error messages when logging fails.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Ron Grabowski</author>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">
+            <summary>
+            Default Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="prefix">The prefix to use for each message.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class
+            with the specified prefix.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Reset">
+            <summary>
+            Reset the error handler back to its initial disabled state.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)">
+            <summary>
+            Log the very first error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <param name="errorCode">The internal error code.</param>
+            <remarks>
+            <para>
+            Sends the error information to <see cref="T:log4net.Util.LogLog"/>'s Error method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
+            <summary>
+            Log an Error
+            </summary>
+            <param name="message">The error message.</param>
+            <param name="e">The exception.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">
+            <summary>
+            Log an error
+            </summary>
+            <param name="message">The error message.</param>
+            <remarks>
+            <para>
+            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.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_enabledDateUtc">
+            <summary>
+            The UTC date the error was recorded.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">
+            <summary>
+            Flag to indicate if it is the first error
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_message">
+            <summary>
+            The message recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_exception">
+            <summary>
+            The exception recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_errorCode">
+            <summary>
+            The error code recorded during the first error.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">
+            <summary>
+            String to prefix each message with
+            </summary>
+        </member>
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.declaringType">
+            <summary>
+            The fully qualified type of the OnlyOnceErrorHandler class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">
+            <summary>
+            Is error logging enabled
+            </summary>
+            <remarks>
+            <para>
+            Is error logging enabled. Logging is only enabled for the
+            first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDate">
+            <summary>
+            The date the first error that trigged this error handler occurred, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDateUtc">
+            <summary>
+            The UTC date the first error that trigged this error handler occured, or <see cref="F:System.DateTime.MinValue"/> if it has not been triggered.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorMessage">
+            <summary>
+            The message from the first error that trigged this error handler.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.Exception">
+            <summary>
+            The exception from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            May be <see langword="null" />.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorCode">
+            <summary>
+            The error code from the first error that trigged this error handler.
+            </summary>
+            <remarks>
+            Defaults to <see cref="F:log4net.Core.ErrorCode.GenericFailure"/>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.OptionConverter">
+            <summary>
+            A convenience class to convert property values to specific types.
+            </summary>
+            <remarks>
+            <para>
+            Utility functions for converting types and parsing values.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.OptionConverter"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToBoolean(System.String,System.Boolean)">
+            <summary>
+            Converts a string to a <see cref="T:System.Boolean"/> value.
+            </summary>
+            <param name="argValue">String to convert.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Boolean"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            If <paramref name="argValue"/> is "true", then <c>true</c> is returned. 
+            If <paramref name="argValue"/> is "false", then <c>false</c> is returned. 
+            Otherwise, <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ToFileSize(System.String,System.Int64)">
+            <summary>
+            Parses a file size into a number.
+            </summary>
+            <param name="argValue">String to parse.</param>
+            <param name="defaultValue">The default value.</param>
+            <returns>The <see cref="T:System.Int64"/> value of <paramref name="argValue"/>.</returns>
+            <remarks>
+            <para>
+            Parses a file size of the form: number[KB|MB|GB] into a
+            long value. It is scaled with the appropriate multiplier.
+            </para>
+            <para>
+            <paramref name="defaultValue"/> is returned when <paramref name="argValue"/>
+            cannot be converted to a <see cref="T:System.Int64"/> value.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertStringTo(System.Type,System.String)">
+            <summary>
+            Converts a string to an object.
+            </summary>
+            <param name="target">The target type to convert to.</param>
+            <param name="txt">The string to convert to an object.</param>
+            <returns>
+            The object converted from a string or <c>null</c> when the 
+            conversion failed.
+            </returns>
+            <remarks>
+            <para>
+            Converts a string to an object. Uses the converter registry to try
+            to convert the string value into the specified target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.CanConvertTypeTo(System.Type,System.Type)">
+            <summary>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            </summary>
+            <param name="sourceType">The type to convert from.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns><c>true</c> if there is a conversion from the source type to the target type.</returns>
+            <remarks>
+            Checks if there is an appropriate type conversion from the source type to the target type.
+            <para>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ConvertTypeTo(System.Object,System.Type)">
+            <summary>
+            Converts an object to the target type.
+            </summary>
+            <param name="sourceInstance">The object to convert to the target type.</param>
+            <param name="targetType">The type to convert to.</param>
+            <returns>The converted object.</returns>
+            <remarks>
+            <para>
+            Converts an object to the target type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">
+            <summary>
+            Instantiates an object given a class name.
+            </summary>
+            <param name="className">The fully qualified class name of the object to instantiate.</param>
+            <param name="superClass">The class to which the new object should belong.</param>
+            <param name="defaultValue">The object to return in case of non-fulfillment.</param>
+            <returns>
+            An instance of the <paramref name="className"/> or <paramref name="defaultValue"/>
+            if the object could not be instantiated.
+            </returns>
+            <remarks>
+            <para>
+            Checks that the <paramref name="className"/> is a subclass of
+            <paramref name="superClass"/>. If that test fails or the object could
+            not be instantiated, then <paramref name="defaultValue"/> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.SubstituteVariables(System.String,System.Collections.IDictionary)">
+            <summary>
+            Performs variable substitution in string <paramref name="value"/> from the 
+            values of keys found in <paramref name="props"/>.
+            </summary>
+            <param name="value">The string on which variable substitution is performed.</param>
+            <param name="props">The dictionary to use to lookup variables.</param>
+            <returns>The result of the substitutions.</returns>
+            <remarks>
+            <para>
+            The variable substitution delimiters are <b>${</b> and <b>}</b>.
+            </para>
+            <para>
+            For example, if props contains <c>key=value</c>, then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of key is ${key}.");
+            </code>
+            </para>
+            <para>
+            will set the variable <c>s</c> to "Value of key is value.".
+            </para>
+            <para>
+            If no value could be found for the specified key, then substitution 
+            defaults to an empty string.
+            </para>
+            <para>
+            For example, if system properties contains no value for the key
+            "nonExistentKey", then the call
+            </para>
+            <para>
+            <code lang="C#">
+            string s = OptionConverter.SubstituteVariables("Value of nonExistentKey is [${nonExistentKey}]");
+            </code>
+            </para>
+            <para>
+            will set <s>s</s> to "Value of nonExistentKey is []".	 
+            </para>
+            <para>
+            An Exception is thrown if <paramref name="value"/> contains a start 
+            delimiter "${" which is not balanced by a stop delimiter "}". 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.OptionConverter.ParseEnum(System.Type,System.String,System.Boolean)">
+            <summary>
+            Converts the string representation of the name or numeric value of one or 
+            more enumerated constants to an equivalent enumerated object.
+            </summary>
+            <param name="enumType">The type to convert to.</param>
+            <param name="value">The enum string value.</param>
+            <param name="ignoreCase">If <c>true</c>, ignore case; otherwise, regard case.</param>
+            <returns>An object of type <paramref name="enumType" /> whose value is represented by <paramref name="value" />.</returns>
+        </member>
+        <member name="F:log4net.Util.OptionConverter.declaringType">
+            <summary>
+            The fully qualified type of the OptionConverter class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser">
+            <summary>
+            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class
+            is delegated to the PatternParser class.
+            </summary>
+            <remarks>
+            <para>
+            The <c>PatternParser</c> processes a pattern string and
+            returns a chain of <see cref="T:log4net.Util.PatternConverter"/> objects.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.PatternParser.#ctor(System.String)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="pattern">The pattern to parse.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternParser"/> class 
+            with the specified pattern string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.Parse">
+            <summary>
+            Parses the pattern into a chain of pattern converters.
+            </summary>
+            <returns>The head of a chain of pattern converters.</returns>
+            <remarks>
+            <para>
+            Parses the pattern into a chain of pattern converters.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.BuildCache">
+            <summary>
+            Build the unified cache of converters from the static and instance maps
+            </summary>
+            <returns>the list of all the converter names</returns>
+            <remarks>
+            <para>
+            Build the unified cache of converters from the static and instance maps
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ParseInternal(System.String,System.String[])">
+            <summary>
+            Internal method to parse the specified pattern to find specified matches
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <param name="matches">the converter names to match in the pattern</param>
+            <remarks>
+            <para>
+            The matches param must be sorted such that longer strings come before shorter ones.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessLiteral(System.String)">
+            <summary>
+            Process a parsed literal
+            </summary>
+            <param name="text">the literal text</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.ProcessConverter(System.String,System.String,log4net.Util.FormattingInfo)">
+            <summary>
+            Process a parsed converter pattern
+            </summary>
+            <param name="converterName">the name of the converter</param>
+            <param name="option">the optional option for the converter</param>
+            <param name="formattingInfo">the formatting info for the converter</param>
+        </member>
+        <member name="M:log4net.Util.PatternParser.AddConverter(log4net.Util.PatternConverter)">
+            <summary>
+            Resets the internal state of the parser and adds the specified pattern converter 
+            to the chain.
+            </summary>
+            <param name="pc">The pattern converter to add.</param>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_head">
+            <summary>
+            The first pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_tail">
+            <summary>
+             the last pattern converter in the chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_pattern">
+            <summary>
+            The pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternParser.m_patternConverters">
+            <summary>
+            Internal map of converter identifiers to converter types
+            </summary>
+            <remarks>
+            <para>
+            This map overrides the static s_globalRulesRegistry map.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.PatternParser.declaringType">
+            <summary>
+            The fully qualified type of the PatternParser class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternParser.PatternConverters">
+            <summary>
+            Get the converter registry used by this parser
+            </summary>
+            <value>
+            The converter registry used by this parser
+            </value>
+            <remarks>
+            <para>
+            Get the converter registry used by this parser
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternParser.StringLengthComparer">
+            <summary>
+            Sort strings by length
+            </summary>
+            <remarks>
+            <para>
+            <see cref="T:System.Collections.IComparer"/> that orders strings by string length.
+            The longest strings are placed first
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PatternString">
+            <summary>
+            This class implements a patterned string.
+            </summary>
+            <remarks>
+            <para>
+            This string has embedded patterns that are resolved and expanded
+            when the string is formatted.
+            </para>
+            <para>
+            This class functions similarly to the <see cref="T:log4net.Layout.PatternLayout"/>
+            in that it accepts a pattern and renders it to a string. Unlike the 
+            <see cref="T:log4net.Layout.PatternLayout"/> however the <c>PatternString</c>
+            does not render the properties of a specific <see cref="T:log4net.Core.LoggingEvent"/> but
+            of the process in general.
+            </para>
+            <para>
+            The recognized conversion pattern names are:
+            </para>
+            <list type="table">
+                <listheader>
+                    <term>Conversion Pattern Name</term>
+                    <description>Effect</description>
+                </listheader>
+                <item>
+                    <term>appdomain</term>
+                    <description>
+                        <para>
+                        Used to output the friendly name of the current AppDomain.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>appsetting</term>
+                    <description>
+                        <para>
+                        Used to output the value of a specific appSetting key in the application
+                        configuration file.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>date</term>
+                    <description>
+            			<para>
+            			Used to output the current date and time in the local time zone. 
+            			To output the date in universal time use the <c>%utcdate</c> pattern.
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%date{HH:mm:ss,fff}</b> or
+            			<b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>env</term>
+                    <description>
+                        <para>
+            			Used to output the a specific environment variable. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%env{COMPUTERNAME}</b> would include the value
+            			of the <c>COMPUTERNAME</c> environment variable.
+                        </para>
+                        <para>
+                        The <c>env</c> pattern is not supported on the .NET Compact Framework.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>identity</term>
+                    <description>
+            			<para>
+            			Used to output the user name for the currently active user
+            			(Principal.Identity.Name).
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>newline</term>
+                    <description>
+            			<para>
+            			Outputs the platform dependent line separator character or
+            			characters.
+            			</para>
+            			<para>
+            			This conversion pattern name offers the same performance as using 
+            			non-portable line separator strings such as	"\n", or "\r\n". 
+            			Thus, it is the preferred way of specifying a line separator.
+            			</para> 
+                    </description>
+                </item>
+                <item>
+                    <term>processid</term>
+                    <description>
+                        <para>
+            			Used to output the system process ID for the current process.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>property</term>
+                    <description>
+            			<para>
+            			Used to output a specific context property. The key to 
+            			lookup must be specified within braces and directly following the
+            			pattern specifier, e.g. <b>%property{user}</b> would include the value
+            			from the property that is keyed by the string 'user'. Each property value
+            			that is to be included in the log must be specified separately.
+            			Properties are stored in logging contexts. By default 
+            			the <c>log4net:HostName</c> property is set to the name of machine on 
+            			which the event was originally logged.
+            			</para>
+            			<para>
+            			If no key is specified, e.g. <b>%property</b> then all the keys and their
+            			values are printed in a comma separated list.
+            			</para>
+            			<para>
+            			The properties of an event are combined from a number of different
+            			contexts. These are listed below in the order in which they are searched.
+            			</para>
+            			<list type="definition">
+            				<item>
+            					<term>the thread properties</term>
+            					<description>
+            					The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current
+            					thread. These properties are shared by all events logged on this thread.
+            					</description>
+            				</item>
+            				<item>
+            					<term>the global properties</term>
+            					<description>
+            					The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These 
+            					properties are shared by all the threads in the AppDomain.
+            					</description>
+            				</item>
+            			</list>
+                    </description>
+                </item>
+                <item>
+                    <term>random</term>
+                    <description>
+                        <para>
+                        Used to output a random string of characters. The string is made up of
+                        uppercase letters and numbers. By default the string is 4 characters long.
+                        The length of the string can be specified within braces directly following the
+            			pattern specifier, e.g. <b>%random{8}</b> would output an 8 character string.
+                        </para>
+                    </description>
+                </item>
+                <item>
+                    <term>username</term>
+                    <description>
+            			<para>
+            			Used to output the WindowsIdentity for the currently
+            			active user.
+            			</para>
+                    </description>
+                </item>
+                <item>
+                    <term>utcdate</term>
+                    <description>
+            			<para>
+            			Used to output the date of the logging event in universal time. 
+            			The date conversion 
+            			specifier may be followed by a <i>date format specifier</i> enclosed 
+            			between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or
+            			<b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is 
+            			given then ISO8601 format is
+            			assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).
+            			</para>
+            			<para>
+            			The date format specifier admits the same syntax as the
+            			time pattern string of the <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+            			<para>
+            			For better results it is recommended to use the log4net date
+            			formatters. These can be specified using one of the strings
+            			"ABSOLUTE", "DATE" and "ISO8601" for specifying 
+            			<see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, 
+            			<see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively 
+            			<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, 
+            			<b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.
+            			</para>
+            			<para>
+            			These dedicated date formatters perform significantly
+            			better than <see cref="M:DateTime.ToString(string)"/>.
+            			</para>
+                    </description>
+                </item>
+            	<item>
+            		<term>%</term>
+            		<description>
+            			<para>
+            			The sequence %% outputs a single percent sign.
+            			</para>
+            		</description>
+            	</item>
+            </list>
+            <para>
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Util.PatternString"/>
+            instance using <see cref="M:AddConverter(ConverterInfo)"/> or
+            <see cref="M:AddConverter(string, Type)"/>.
+            </para>
+            <para>
+            See the <see cref="T:log4net.Layout.PatternLayout"/> for details on the 
+            <i>format modifiers</i> supported by the patterns.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.PatternString.s_globalRulesRegistry">
+            <summary>
+            Internal map of converter identifiers to converter types.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_pattern">
+            <summary>
+            the pattern
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_head">
+            <summary>
+            the head of the pattern converter chain
+            </summary>
+        </member>
+        <member name="F:log4net.Util.PatternString.m_instanceRulesRegistry">
+            <summary>
+            patterns defined on this PatternString only
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#cctor">
+            <summary>
+            Initialize the global registry
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.#ctor(System.String)">
+            <summary>
+            Constructs a PatternString
+            </summary>
+            <param name="pattern">The pattern to use with this PatternString</param>
+            <remarks>
+            <para>
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/> with the pattern specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.ActivateOptions">
+            <summary>
+            Initialize object options
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.PatternString.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.PatternString.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.PatternString.ActivateOptions"/> must be called again.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.CreatePatternParser(System.String)">
+            <summary>
+            Create the <see cref="T:log4net.Util.PatternParser"/> used to parse the pattern
+            </summary>
+            <param name="pattern">the pattern to parse</param>
+            <returns>The <see cref="T:log4net.Util.PatternParser"/></returns>
+            <remarks>
+            <para>
+            Returns PatternParser used to parse the conversion string. Subclasses
+            may override this to return a subclass of PatternParser which recognize
+            custom conversion pattern name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format(System.IO.TextWriter)">
+            <summary>
+            Produces a formatted string as specified by the conversion pattern.
+            </summary>
+            <param name="writer">The TextWriter to write the formatted event to</param>
+            <remarks>
+            <para>
+            Format the pattern to the <paramref name="writer"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.Format">
+            <summary>
+            Format the pattern as a string
+            </summary>
+            <returns>the pattern formatted as a string</returns>
+            <remarks>
+            <para>
+            Format the pattern to a string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(log4net.Util.ConverterInfo)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="converterInfo">the converter info</param>
+            <remarks>
+            <para>
+            This version of the method is used by the configurator.
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PatternString.AddConverter(System.String,System.Type)">
+            <summary>
+            Add a converter to this PatternString
+            </summary>
+            <param name="name">the name of the conversion pattern for this converter</param>
+            <param name="type">the type of the converter</param>
+            <remarks>
+            <para>
+            Add a converter to this PatternString
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PatternString.ConversionPattern">
+            <summary>
+            Gets or sets the pattern formatting string
+            </summary>
+            <value>
+            The pattern formatting string
+            </value>
+            <remarks>
+            <para>
+            The <b>ConversionPattern</b> option. This is the string which
+            controls formatting and consists of a mix of literal content and
+            conversion specifiers.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.PropertiesDictionary">
+            <summary>
+            String keyed object map.
+            </summary>
+            <remarks>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="T:log4net.Util.ReadOnlyPropertiesDictionary">
+            <summary>
+            String keyed object map that is read only.
+            </summary>
+            <remarks>
+            <para>
+            This collection is readonly and cannot be modified.
+            </para>
+            <para>
+            While this collection is serializable only member 
+            objects that are serializable will
+            be serialized along with this collection.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="F:log4net.Util.ReadOnlyPropertiesDictionary.m_hashtable">
+            <summary>
+            The Hashtable used to store the properties data
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Copy Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Deserialization constructor
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class 
+            with serialized data.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetKeys">
+            <summary>
+            Gets the key names.
+            </summary>
+            <returns>An array of all the keys.</returns>
+            <remarks>
+            <para>
+            Gets the key names.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Contains(System.String)">
+            <summary>
+            Test if the dictionary contains a specified key
+            </summary>
+            <param name="key">the key to look for</param>
+            <returns>true if the dictionary contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if the dictionary contains a specified key
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
+            <param name="context">The destination for this serialization.</param>
+            <remarks>
+            <para>
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <returns></returns>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key"></param>
+            <param name="value"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.InnerHashtable">
+            <summary>
+            The hashtable used to store the properties
+            </summary>
+            <value>
+            The internal collection used to store the properties
+            </value>
+            <remarks>
+            <para>
+            The hashtable used to store the properties
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Count">
+            <summary>
+            The number of properties in this collection
+            </summary>
+        </member>
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="propertiesDictionary">properties to copy</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class 
+            with serialized data.
+            </summary>
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
+            <remarks>
+            <para>
+            Because this class is sealed the serialization constructor is private.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Remove(System.String)">
+            <summary>
+            Remove the entry with the specified key from this dictionary
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>
+            </summary>
+            <returns>an enumerator</returns>
+            <remarks>
+            <para>
+            Returns a <see cref="T:System.Collections.IDictionaryEnumerator"/> over the contest of this collection.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>
+            </summary>
+            <param name="key">the key to remove</param>
+            <remarks>
+            <para>
+            Remove the entry with the specified key from this dictionary
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>
+            </summary>
+            <param name="key">the key to lookup in the collection</param>
+            <returns><c>true</c> if the collection contains the specified key</returns>
+            <remarks>
+            <para>
+            Test if this collection contains a specified key.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.Clear">
+            <summary>
+            Remove all properties from the properties collection
+            </summary>
+            <remarks>
+            <para>
+            Remove all properties from the properties collection
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">
+            <summary>
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>
+            </summary>
+            <param name="key">the key</param>
+            <param name="value">the value to store for the key</param>
+            <remarks>
+            <para>
+            Store a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">
+            <summary>
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>
+            </summary>
+            <param name="array"></param>
+            <param name="index"></param>
+        </member>
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
+            <summary>
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.Item(System.String)">
+            <summary>
+            Gets or sets the value of the  property with the specified key.
+            </summary>
+            <value>
+            The value of the property with the specified key.
+            </value>
+            <param name="key">The key of the property to get or set.</param>
+            <remarks>
+            <para>
+            The property value will only be serialized if it is serializable.
+            If it cannot be serialized it will be silently ignored if
+            a serialization operation is performed.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsReadOnly">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>
+            </summary>
+            <value>
+            <c>false</c>
+            </value>
+            <remarks>
+            <para>
+            This collection is modifiable. This property always
+            returns <c>false</c>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>
+            </summary>
+            <value>
+            The value for the key specified.
+            </value>
+            <remarks>
+            <para>
+            Get or set a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Values">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Values"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Keys">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.Keys"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsFixedSize">
+            <summary>
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#IsSynchronized">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>
+            </summary>
+        </member>
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#SyncRoot">
+            <summary>
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>
+            </summary>
+        </member>
+        <member name="T:log4net.Util.PropertyEntry">
+            <summary>
+            A class to hold the key and data for a property set in the config file
+            </summary>
+            <remarks>
+            <para>
+            A class to hold the key and data for a property set in the config file
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.PropertyEntry.ToString">
+            <summary>
+            Override <c>Object.ToString</c> to return sensible debug info
+            </summary>
+            <returns>string info about this object</returns>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Key">
+            <summary>
+            Property Key
+            </summary>
+            <value>
+            Property Key
+            </value>
+            <remarks>
+            <para>
+            Property Key.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.PropertyEntry.Value">
+            <summary>
+            Property Value
+            </summary>
+            <value>
+            Property Value
+            </value>
+            <remarks>
+            <para>
+            Property Value.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ProtectCloseTextWriter">
+            <summary>
+            A <see cref="T:System.IO.TextWriter"/> that ignores the <see cref="M:log4net.Util.ProtectCloseTextWriter.Close"/> message
+            </summary>
+            <remarks>
+            <para>
+            This writer is used in special cases where it is necessary 
+            to protect a writer from being closed by a client.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.#ctor(System.IO.TextWriter)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="writer">the writer to actually write to</param>
+            <remarks>
+            <para>
+            Create a new ProtectCloseTextWriter using a writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Attach(System.IO.TextWriter)">
+            <summary>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </summary>
+            <param name="writer">the writer to attach to</param>
+            <remarks>
+            <para>
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Close">
+            <summary>
+            Does not close the underlying output writer.
+            </summary>
+            <remarks>
+            <para>
+            Does not close the underlying output writer.
+            This method does nothing.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReaderWriterLock">
+            <summary>
+            Defines a lock that supports single writers and multiple readers
+            </summary>
+            <remarks>
+            <para>
+            <c>ReaderWriterLock</c> is used to synchronize access to a resource. 
+            At any given time, it allows either concurrent read access for 
+            multiple threads, or write access for a single thread. In a 
+            situation where a resource is changed infrequently, a 
+            <c>ReaderWriterLock</c> provides better throughput than a simple 
+            one-at-a-time lock, such as <see cref="T:System.Threading.Monitor"/>.
+            </para>
+            <para>
+            If a platform does not support a <c>System.Threading.ReaderWriterLock</c> 
+            implementation then all readers and writers are serialized. Therefore 
+            the caller must not rely on multiple simultaneous readers.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.#ctor">
+            <summary>
+            Constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ReaderWriterLock"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireReaderLock">
+            <summary>
+            Acquires a reader lock
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.AcquireReaderLock"/> blocks if a different thread has the writer 
+            lock, or if at least one thread is waiting for the writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock">
+            <summary>
+            Decrements the lock count
+            </summary>
+            <remarks>
+            <para>
+            <see cref="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock"/> decrements the lock count. When the count 
+            reaches zero, the lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireWriterLock">
+            <summary>
+            Acquires the writer lock
+            </summary>
+            <remarks>
+            <para>
+            This method blocks if another thread has a reader lock or writer lock.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseWriterLock">
+            <summary>
+            Decrements the lock count on the writer lock
+            </summary>
+            <remarks>
+            <para>
+            ReleaseWriterLock decrements the writer lock count. 
+            When the count reaches zero, the writer lock is released.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ReusableStringWriter">
+            <summary>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused
+            </summary>
+            <remarks>
+            <para>
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.
+            This uses a single buffer for string operations.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">
+            <summary>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </summary>
+            <param name="formatProvider">the format provider to use</param>
+            <remarks>
+            <para>
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">
+            <summary>
+            Override Dispose to prevent closing of writer
+            </summary>
+            <param name="disposing">flag</param>
+            <remarks>
+            <para>
+            Override Dispose to prevent closing of writer
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">
+            <summary>
+            Reset this string writer so that it can be reused.
+            </summary>
+            <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>
+            <param name="defaultSize">the default size to make the buffer</param>
+            <remarks>
+            <para>
+            Reset this string writer so that it can be reused.
+            The internal buffers are cleared and reset.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemInfo">
+            <summary>
+            Utility class for system specific information.
+            </summary>
+            <remarks>
+            <para>
+            Utility class of static methods for system specific information.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+            <author>Alexey Solofnenko</author>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#ctor">
+            <summary>
+            Private constructor to prevent instances.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.#cctor">
+            <summary>
+            Initialize default values for private static fields.
+            </summary>
+            <remarks>
+            <para>
+            Only static methods are exposed from this type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyLocationInfo(System.Reflection.Assembly)">
+            <summary>
+            Gets the assembly location path for the specified assembly.
+            </summary>
+            <param name="myAssembly">The assembly to get the location for.</param>
+            <returns>The location of the assembly.</returns>
+            <remarks>
+            <para>
+            This method does not guarantee to return the correct path
+            to the assembly. If only tries to give an indication as to
+            where the assembly was loaded from.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyQualifiedName(System.Type)">
+            <summary>
+            Gets the fully qualified name of the <see cref="T:System.Type"/>, including 
+            the name of the assembly from which the <see cref="T:System.Type"/> was 
+            loaded.
+            </summary>
+            <param name="type">The <see cref="T:System.Type"/> to get the fully qualified name for.</param>
+            <returns>The fully qualified name for the <see cref="T:System.Type"/>.</returns>
+            <remarks>
+            <para>
+            This is equivalent to the <c>Type.AssemblyQualifiedName</c> property,
+            but this method works on the .NET Compact Framework 1.0 as well as
+            the full .NET runtime.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyShortName(System.Reflection.Assembly)">
+            <summary>
+            Gets the short name of the <see cref="T:System.Reflection.Assembly"/>.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the name for.</param>
+            <returns>The short name of the <see cref="T:System.Reflection.Assembly"/>.</returns>
+            <remarks>
+            <para>
+            The short name of the assembly is the <see cref="P:System.Reflection.Assembly.FullName"/> 
+            without the version, culture, or public key. i.e. it is just the 
+            assembly's file name without the extension.
+            </para>
+            <para>
+            Use this rather than <c>Assembly.GetName().Name</c> because that
+            is not available on the Compact Framework.
+            </para>
+            <para>
+            Because of a FileIOPermission security demand we cannot do
+            the obvious Assembly.GetName().Name. We are allowed to get
+            the <see cref="P:System.Reflection.Assembly.FullName"/> of the assembly so we 
+            start from there and strip out just the assembly name.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.AssemblyFileName(System.Reflection.Assembly)">
+            <summary>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </summary>
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the file name for.</param>
+            <returns>The file name of the assembly.</returns>
+            <remarks>
+            <para>
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Type,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeType">A sibling type to use to load the type.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified, it will be loaded from the assembly
+            containing the specified relative type. If the type is not found in the assembly 
+            then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>		
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the
+            assembly that is directly calling this method. If the type is not found 
+            in the assembly then all the loaded assemblies will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Reflection.Assembly,System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Loads the type specified in the type string.
+            </summary>
+            <param name="relativeAssembly">An assembly to load the type from.</param>
+            <param name="typeName">The name of the type to load.</param>
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
+            <remarks>
+            <para>
+            If the type name is fully qualified, i.e. if contains an assembly name in 
+            the type name, the type will be loaded from the system using 
+            <see cref="M:Type.GetType(string,bool)"/>.
+            </para>
+            <para>
+            If the type name is not fully qualified it will be loaded from the specified
+            assembly. If the type is not found in the assembly then all the loaded assemblies 
+            will be searched for the type.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.NewGuid">
+            <summary>
+            Generate a new guid
+            </summary>
+            <returns>A new Guid</returns>
+            <remarks>
+            <para>
+            Generate a new guid
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateArgumentOutOfRangeException(System.String,System.Object,System.String)">
+            <summary>
+            Create an <see cref="T:System.ArgumentOutOfRangeException"/>
+            </summary>
+            <param name="parameterName">The name of the parameter that caused the exception</param>
+            <param name="actualValue">The value of the argument that causes this exception</param>
+            <param name="message">The message that describes the error</param>
+            <returns>the ArgumentOutOfRangeException object</returns>
+            <remarks>
+            <para>
+            Create a new instance of the <see cref="T:System.ArgumentOutOfRangeException"/> class 
+            with a specified error message, the parameter name, and the value 
+            of the argument.
+            </para>
+            <para>
+            The Compact Framework does not support the 3 parameter constructor for the
+            <see cref="T:System.ArgumentOutOfRangeException"/> type. This method provides an
+            implementation that works for all platforms.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int32@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int32"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int64@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int64"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int16@)">
+            <summary>
+            Parse a string into an <see cref="T:System.Int16"/> value
+            </summary>
+            <param name="s">the string to parse</param>
+            <param name="val">out param where the parsed value is placed</param>
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>
+            <remarks>
+            <para>
+            Attempts to parse the string into an integer. If the string cannot
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.GetAppSetting(System.String)">
+            <summary>
+            Lookup an application setting
+            </summary>
+            <param name="key">the application settings key to lookup</param>
+            <returns>the value for the key, or <c>null</c></returns>
+            <remarks>
+            <para>
+            Configuration APIs are not supported under the Compact Framework
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.ConvertToFullPath(System.String)">
+            <summary>
+            Convert a path into a fully qualified local file path.
+            </summary>
+            <param name="path">The path to convert.</param>
+            <returns>The fully qualified path.</returns>
+            <remarks>
+            <para>
+            Converts the path specified to a fully
+            qualified path. If the path is relative it is
+            taken as relative from the application base 
+            directory.
+            </para>
+            <para>
+            The path specified must be a local file path, a URI is not supported.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.CreateCaseInsensitiveHashtable">
+            <summary>
+            Creates a new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity. 
+            </summary>
+            <returns>A new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity</returns>
+            <remarks>
+            <para>
+            The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemInfo.EqualsIgnoringCase(System.String,System.String)">
+            <summary>
+            Tests two strings for equality, the ignoring case.
+            </summary>
+            <remarks>
+            If the platform permits, culture information is ignored completely (ordinal comparison).
+            The aim of this method is to provide a fast comparison that deals with <c>null</c> and ignores different casing.
+            It is not supposed to deal with various, culture-specific habits.
+            Use it to compare against pure ASCII constants, like keywords etc.
+            </remarks>
+            <param name="a">The one string.</param>
+            <param name="b">The other string.</param>
+            <returns><c>true</c> if the strings are equal, <c>false</c> otherwise.</returns>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.EmptyTypes">
+            <summary>
+            Gets an empty array of types.
+            </summary>
+            <remarks>
+            <para>
+            The <c>Type.EmptyTypes</c> field is not available on
+            the .NET Compact Framework 1.0.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.declaringType">
+            <summary>
+            The fully qualified type of the SystemInfo class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_hostName">
+            <summary>
+            Cache the host name for the current machine
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_appFriendlyName">
+            <summary>
+            Cache the application friendly name
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_nullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_notAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemInfo.s_processStartTimeUtc">
+            <summary>
+            Start time for the current process.
+            </summary>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NewLine">
+            <summary>
+            Gets the system dependent line terminator.
+            </summary>
+            <value>
+            The system dependent line terminator.
+            </value>
+            <remarks>
+            <para>
+            Gets the system dependent line terminator.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationBaseDirectory">
+            <summary>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The base directory path for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ConfigurationFileLocation">
+            <summary>
+            Gets the path to the configuration file for the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the configuration file for the current <see cref="T:System.AppDomain"/>.</value>
+            <remarks>
+            <para>
+            The .NET Compact Framework 1.0 does not have a concept of a configuration
+            file. For this runtime, we use the entry assembly location as the root for
+            the configuration file name.
+            </para>
+            <para>
+            The value returned may be either a local file path or a URI.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.EntryAssemblyLocation">
+            <summary>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </summary>
+            <value>The path to the entry assembly.</value>
+            <remarks>
+            <para>
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.CurrentThreadId">
+            <summary>
+            Gets the ID of the current thread.
+            </summary>
+            <value>The ID of the current thread.</value>
+            <remarks>
+            <para>
+            On the .NET framework, the <c>AppDomain.GetCurrentThreadId</c> method
+            is used to obtain the thread ID for the current thread. This is the 
+            operating system ID for the thread.
+            </para>
+            <para>
+            On the .NET Compact Framework 1.0 it is not possible to get the 
+            operating system thread ID for the current thread. The native method 
+            <c>GetCurrentThreadId</c> is implemented inline in a header file
+            and cannot be called.
+            </para>
+            <para>
+            On the .NET Framework 2.0 the <c>Thread.ManagedThreadId</c> is used as this
+            gives a stable id unrelated to the operating system thread ID which may 
+            change if the runtime is using fibers.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.HostName">
+            <summary>
+            Get the host name or machine name for the current machine
+            </summary>
+            <value>
+            The hostname or machine name
+            </value>
+            <remarks>
+            <para>
+            Get the host name or machine name for the current machine
+            </para>
+            <para>
+            The host name (<see cref="M:System.Net.Dns.GetHostName"/>) or
+            the machine name (<c>Environment.MachineName</c>) for
+            the current machine, or if neither of these are available
+            then <c>NOT AVAILABLE</c> is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ApplicationFriendlyName">
+            <summary>
+            Get this application's friendly name
+            </summary>
+            <value>
+            The friendly name of this application as a string
+            </value>
+            <remarks>
+            <para>
+            If available the name of the application is retrieved from
+            the <c>AppDomain</c> using <c>AppDomain.CurrentDomain.FriendlyName</c>.
+            </para>
+            <para>
+            Otherwise the file name of the entry assembly is used.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTime">
+            <summary>
+            Get the start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTimeUtc">
+            <summary>
+            Get the UTC start time for the current process.
+            </summary>
+            <remarks>
+            <para>
+            This is the UTC time at which the log4net library was loaded into the
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>
+            this is not the start time for the current process.
+            </para>
+            <para>
+            The log4net library should be loaded by an application early during its
+            startup, therefore this start time should be a good approximation for
+            the actual start time.
+            </para>
+            <para>
+            Note that AppDomains may be loaded and unloaded within the
+            same process without the process terminating, however this start time
+            will be set per AppDomain.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NullText">
+            <summary>
+            Text to output when a <c>null</c> is encountered.
+            </summary>
+            <remarks>
+            <para>
+            Use this value to indicate a <c>null</c> has been encountered while
+            outputting a string representation of an item.
+            </para>
+            <para>
+            The default value is <c>(null)</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NullText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.SystemInfo.NotAvailableText">
+            <summary>
+            Text to output when an unsupported feature is requested.
+            </summary>
+            <remarks>
+            <para>
+            Use this value when an unsupported feature is requested.
+            </para>
+            <para>
+            The default value is <c>NOT AVAILABLE</c>. This value can be overridden by specifying
+            a value for the <c>log4net.NotAvailableText</c> appSetting in the application's
+            .config file.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.SystemStringFormat">
+            <summary>
+            Utility class that represents a format string.
+            </summary>
+            <remarks>
+            <para>
+            Utility class that represents a format string.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.#ctor(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Initialise the <see cref="T:log4net.Util.SystemStringFormat"/>
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.ToString">
+            <summary>
+            Format the string and arguments
+            </summary>
+            <returns>the formatted string</returns>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormat(System.IFormatProvider,System.String,System.Object[])">
+            <summary>
+            Replaces the format item in a specified <see cref="T:System.String"/> with the text equivalent 
+            of the value of a corresponding <see cref="T:System.Object"/> instance in a specified array.
+            A specified parameter supplies culture-specific formatting information.
+            </summary>
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
+            <returns>
+            A copy of format in which the format items have been replaced by the <see cref="T:System.String"/> 
+            equivalent of the corresponding instances of <see cref="T:System.Object"/> in args.
+            </returns>
+            <remarks>
+            <para>
+            This method does not throw exceptions. If an exception thrown while formatting the result the
+            exception and arguments are returned in the result string.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.StringFormatError(System.Exception,System.String,System.Object[])">
+            <summary>
+            Process an error during StringFormat
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderArray(System.Array,System.Text.StringBuilder)">
+            <summary>
+            Dump the contents of an array into a string builder
+            </summary>
+        </member>
+        <member name="M:log4net.Util.SystemStringFormat.RenderObject(System.Object,System.Text.StringBuilder)">
+            <summary>
+            Dump an object to a string
+            </summary>
+        </member>
+        <member name="F:log4net.Util.SystemStringFormat.declaringType">
+            <summary>
+            The fully qualified type of the SystemStringFormat class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextProperties">
+            <summary>
+            Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Class implements a collection of properties that is specific to each thread.
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextProperties._dictionary">
+            <summary>
+            Each thread will automatically have its instance.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">
+            <summary>
+            Remove a property
+            </summary>
+            <param name="key">the key for the entry to remove</param>
+            <remarks>
+            <para>
+            Remove a property
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetKeys">
+            <summary>
+            Get the keys stored in the properties.
+            </summary>
+            <para>
+            Gets the keys stored in the properties.
+            </para>
+            <returns>a set of the defined keys</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.Clear">
+            <summary>
+            Clear all properties
+            </summary>
+            <remarks>
+            <para>
+            Clear all properties
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextProperties.GetProperties(System.Boolean)">
+            <summary>
+            Get the <c>PropertiesDictionary</c> for this thread.
+            </summary>
+            <param name="create">create the dictionary if it does not exist, otherwise return null if does not exist</param>
+            <returns>the properties for this thread</returns>
+            <remarks>
+            <para>
+            The collection returned is only to be used on the calling thread. If the
+            caller needs to share the collection between different threads then the 
+            caller must clone the collection before doing so.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextProperties.Item(System.String)">
+            <summary>
+            Gets or sets the value of a property
+            </summary>
+            <value>
+            The value for the property with the specified key
+            </value>
+            <remarks>
+            <para>
+            Gets or sets the value of a property
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack">
+            <summary>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.m_stack">
+            <summary>
+            The stack store.
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.#ctor">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack"/> class. 
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Clear">
+            <summary>
+            Clears all the contextual information held in this stack.
+            </summary>
+            <remarks>
+            <para>
+            Clears all the contextual information held in this stack.
+            Only call this if you think that this tread is being reused after
+            a previous call execution which may not have completed correctly.
+            You do not need to use this method if you always guarantee to call
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>
+            returned from <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> even in exceptional circumstances,
+            for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> 
+            syntax.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Pop">
+            <summary>
+            Removes the top context from this stack.
+            </summary>
+            <returns>The message in the context that was removed from the top of this stack.</returns>
+            <remarks>
+            <para>
+            Remove the top context from this stack, and return
+            it to the caller. If this stack is empty then an
+            empty string (not <see langword="null"/>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.Push(System.String)">
+            <summary>
+            Pushes a new context message into this stack.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.
+            </returns>
+            <remarks>
+            <para>
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up this stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))
+            {
+            	log.Warn("This should have an ThreadContext Stack message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.GetFullMessage">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>The current context information.</returns>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.ToString">
+            <summary>
+            Gets the current context information for this stack.
+            </summary>
+            <returns>Gets the current context information</returns>
+            <remarks>
+            <para>
+            Gets the current context information for this stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">
+            <summary>
+            Get a portable version of this object
+            </summary>
+            <returns>the portable instance of this object</returns>
+            <remarks>
+            <para>
+            Get a cross thread portable version of this object
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.Count">
+            <summary>
+            The number of messages in the stack
+            </summary>
+            <value>
+            The current number of messages in the stack
+            </value>
+            <remarks>
+            <para>
+            The current number of messages in the stack. That is
+            the number of times <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> has been called
+            minus the number of times <see cref="M:log4net.Util.ThreadContextStack.Pop"/> has been called.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.InternalStack">
+            <summary>
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.ThreadContextStack"/>
+            </summary>
+            <value>The internal storage stack</value>
+            <remarks>
+            <para>
+            This property is provided only to support backward compatability 
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not
+            be modified.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.StackFrame">
+            <summary>
+            Inner class used to represent a single context frame in the stack.
+            </summary>
+            <remarks>
+            <para>
+            Inner class used to represent a single context frame in the stack.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.ThreadContextStack.StackFrame)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="message">The message for this context.</param>
+            <param name="parent">The parent context in the chain.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.StackFrame"/> class
+            with the specified message and parent context.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.Message">
+            <summary>
+            Get the message.
+            </summary>
+            <value>The message.</value>
+            <remarks>
+            <para>
+            Get the message.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.FullMessage">
+            <summary>
+            Gets the full text of the context down to the root level.
+            </summary>
+            <value>
+            The full text of the context down to the root level.
+            </value>
+            <remarks>
+            <para>
+            Gets the full text of the context down to the root level.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStack.AutoPopStackFrame">
+            <summary>
+            Struct returned from the <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> method.
+            </summary>
+            <remarks>
+            <para>
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameStack">
+            <summary>
+            The ThreadContextStack internal stack
+            </summary>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameDepth">
+            <summary>
+            The depth to trim the stack to when this instance is disposed
+            </summary>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.#ctor(System.Collections.Stack,System.Int32)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="frameStack">The internal stack used by the ThreadContextStack.</param>
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.AutoPopStackFrame"/> class with
+            the specified stack and return depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.Dispose">
+            <summary>
+            Returns the stack to the correct depth.
+            </summary>
+            <remarks>
+            <para>
+            Returns the stack to the correct depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.ThreadContextStacks">
+            <summary>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">
+            <summary>
+            Internal constructor
+            </summary>
+            <remarks>
+            <para>
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.ThreadContextStacks.declaringType">
+            <summary>
+            The fully qualified type of the ThreadContextStacks class.
+            </summary>
+            <remarks>
+            Used by the internal logger to record the Type of the
+            log message.
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">
+            <summary>
+            Gets the named thread context stack
+            </summary>
+            <value>
+            The named stack
+            </value>
+            <remarks>
+            <para>
+            Gets the named thread context stack
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.Transform">
+            <summary>
+            Utility class for transforming strings.
+            </summary>
+            <remarks>
+            <para>
+            Utility class for transforming strings.
+            </para>
+            </remarks>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.Util.Transform.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.Util.Transform"/> class. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.WriteEscapedXmlString(System.Xml.XmlWriter,System.String,System.String)">
+            <summary>
+            Write a string to an <see cref="T:System.Xml.XmlWriter"/>
+            </summary>
+            <param name="writer">the writer to write to</param>
+            <param name="textData">the string to write</param>
+            <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param>
+            <remarks>
+            <para>
+            The test is escaped either using XML escape entities
+            or using CDATA sections.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.MaskXmlInvalidCharacters(System.String,System.String)">
+            <summary>
+            Replace invalid XML characters in text string
+            </summary>
+            <param name="textData">the XML text input string</param>
+            <param name="mask">the string to use in place of invalid characters</param>
+            <returns>A string that does not contain invalid XML characters.</returns>
+            <remarks>
+            <para>
+            Certain Unicode code points are not allowed in the XML InfoSet, for
+            details see: <a href="http://www.w3.org/TR/REC-xml/#charsets">http://www.w3.org/TR/REC-xml/#charsets</a>.
+            </para>
+            <para>
+            This method replaces any illegal characters in the input string
+            with the mask string specified.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.Transform.CountSubstrings(System.String,System.String)">
+            <summary>
+            Count the number of times that the substring occurs in the text
+            </summary>
+            <param name="text">the text to search</param>
+            <param name="substring">the substring to find</param>
+            <returns>the number of times the substring occurs in the text</returns>
+            <remarks>
+            <para>
+            The substring is assumed to be non repeating within itself.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.Transform.INVALIDCHARS">
+            <summary>
+            Characters illegal in XML 1.0
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext">
+            <summary>
+            Impersonate a Windows Account
+            </summary>
+            <remarks>
+            <para>
+            This <see cref="T:log4net.Core.SecurityContext"/> impersonates a Windows account.
+            </para>
+            <para>
+            How the impersonation is done depends on the value of <see cref="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)"/>.
+            This allows the context to either impersonate a set of user credentials specified 
+            using username, domain name and password or to revert to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+            <remarks>
+            <para>
+            Default constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.ActivateOptions">
+            <summary>
+            Initialize the SecurityContext based on the options set.
+            </summary>
+            <remarks>
+            <para>
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
+            activation scheme. The <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> method must 
+            be called on this object after the configuration properties have
+            been set. Until <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> is called this
+            object is in an undefined state and must not be used. 
+            </para>
+            <para>
+            If any of the configuration properties are modified then 
+            <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> must be called again.
+            </para>
+            <para>
+            The security context will try to Logon the specified user account and
+            capture a primary token for impersonation.
+            </para>
+            </remarks>
+            <exception cref="T:System.ArgumentNullException">The required <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, 
+            <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> or <see cref="P:log4net.Util.WindowsSecurityContext.Password"/> properties were not specified.</exception>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)">
+            <summary>
+            Impersonate the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.
+            </summary>
+            <param name="state">caller provided state</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> instance that will revoke the impersonation of this SecurityContext
+            </returns>
+            <remarks>
+            <para>
+            Depending on the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property either
+            impersonate a user using credentials supplied or revert 
+            to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.LogonUser(System.String,System.String,System.String)">
+            <summary>
+            Create a <see cref="T:System.Security.Principal.WindowsIdentity"/> given the userName, domainName and password.
+            </summary>
+            <param name="userName">the user name</param>
+            <param name="domainName">the domain name</param>
+            <param name="password">the password</param>
+            <returns>the <see cref="T:System.Security.Principal.WindowsIdentity"/> for the account specified</returns>
+            <remarks>
+            <para>
+            Uses the Windows API call LogonUser to get a principal token for the account. This
+            token is used to initialize the WindowsIdentity.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Credentials">
+            <summary>
+            Gets or sets the impersonation mode for this security context
+            </summary>
+            <value>
+            The impersonation mode for this security context
+            </value>
+            <remarks>
+            <para>
+            Impersonate either a user with user credentials or
+            revert this thread to the credentials of the process.
+            The value is one of the <see cref="T:log4net.Util.WindowsSecurityContext.ImpersonationMode"/>
+            enum.
+            </para>
+            <para>
+            The default value is <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>
+            the user's credentials are established using the
+            <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.Password"/>
+            values.
+            </para>
+            <para>
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process"/>
+            no other properties need to be set. If the calling thread is 
+            impersonating then it will be reverted back to the process credentials.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.UserName">
+            <summary>
+            Gets or sets the Windows username for this security context
+            </summary>
+            <value>
+            The Windows username for this security context
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.DomainName">
+            <summary>
+            Gets or sets the Windows domain name for this security context
+            </summary>
+            <value>
+            The Windows domain name for this security context
+            </value>
+            <remarks>
+            <para>
+            The default value for <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> is the local machine name
+            taken from the <see cref="P:System.Environment.MachineName"/> property.
+            </para>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.Util.WindowsSecurityContext.Password">
+            <summary>
+            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.
+            </summary>
+            <value>
+            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.
+            </value>
+            <remarks>
+            <para>
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.ImpersonationMode">
+            <summary>
+            The impersonation modes for the <see cref="T:log4net.Util.WindowsSecurityContext"/>
+            </summary>
+            <remarks>
+            <para>
+            See the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property for
+            details.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User">
+            <summary>
+            Impersonate a user using the credentials supplied
+            </summary>
+        </member>
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process">
+            <summary>
+            Revert this the thread to the credentials of the process
+            </summary>
+        </member>
+        <member name="T:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext">
+            <summary>
+            Adds <see cref="T:System.IDisposable"/> to <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            </summary>
+            <remarks>
+            <para>
+            Helper class to expose the <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>
+            through the <see cref="T:System.IDisposable"/> interface.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.#ctor(System.Security.Principal.WindowsImpersonationContext)">
+            <summary>
+            Constructor
+            </summary>
+            <param name="impersonationContext">the impersonation context being wrapped</param>
+            <remarks>
+            <para>
+            Constructor
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.Dispose">
+            <summary>
+            Revert the impersonation
+            </summary>
+            <remarks>
+            <para>
+            Revert the impersonation
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.GlobalContext">
+            <summary>
+            The log4net Global Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>GlobalContext</c> provides a location for global debugging 
+            information to be stored.
+            </para>
+            <para>
+            The global context has a properties map and these properties can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputing these properties.
+            </para>
+            <para>
+            By default the <c>log4net:HostName</c> property is set to the name of 
+            the current machine.
+            </para>
+            </remarks>
+            <example>
+            <code lang="C#">
+            GlobalContext.Properties["hostname"] = Environment.MachineName;
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.GlobalContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="F:log4net.GlobalContext.s_properties">
+            <summary>
+            The global context properties instance
+            </summary>
+        </member>
+        <member name="P:log4net.GlobalContext.Properties">
+            <summary>
+            The global properties map.
+            </summary>
+            <value>
+            The global properties map.
+            </value>
+            <remarks>
+            <para>
+            The global properties map.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.AssemblyInfo">
+            <summary>
+            Provides information about the environment the assembly has
+            been built for.
+            </summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.Version">
+            <summary>Version of the assembly</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFrameworkVersion">
+            <summary>Version of the framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.TargetFramework">
+            <summary>Type of framework targeted</summary>
+        </member>
+        <member name="F:log4net.AssemblyInfo.ClientProfile">
+            <summary>Does it target a client profile?</summary>
+        </member>
+        <member name="P:log4net.AssemblyInfo.Info">
+            <summary>
+            Identifies the version and target for this assembly.
+            </summary>
+        </member>
+        <member name="T:log4net.LogicalThreadContext">
+            <summary>
+            The log4net Logical Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> provides a location for <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> specific debugging 
+            information to be stored.
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> or <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            For .NET Standard 1.3 this class uses
+            System.Threading.AsyncLocal rather than <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>.
+            </para>
+            <para>
+            The Logical Thread Context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Logical Thread Context provides a diagnostic context for the current call context. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Logical Thread Context is managed on a per <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> basis.
+            </para>
+            <para>
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time 
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.
+            If the calling code does not have this permission then this context will be disabled.
+            It will not store any property values set on it.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            LogicalThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a LogicalThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.LogicalThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.LogicalThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> 
+            or <see cref="T:log4net.GlobalContext"/> properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.LogicalThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The logical thread stacks.
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.LogManager">
+            <summary>
+            This class is used by client applications to request logger instances.
+            </summary>
+            <remarks>
+            <para>
+            This class has static methods that are used by a client to request
+            a logger instance. The <see cref="M:GetLogger(string)"/> method is 
+            used to retrieve a logger.
+            </para>
+            <para>
+            See the <see cref="T:log4net.ILog"/> interface for more details.
+            </para>
+            </remarks>
+            <example>Simple example of logging messages
+            <code lang="C#">
+            ILog log = LogManager.GetLogger("application-log");
+            
+            log.Info("Application Start");
+            log.Debug("This is a debug message");
+            
+            if (log.IsDebugEnabled)
+            {
+            	log.Debug("This is another debug message");
+            }
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <seealso cref="T:log4net.ILog"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.LogManager.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.LogManager"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String)">
+            <overloads>Returns the named logger if it exists.</overloads>
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the default repository) then it
+            returns a reference to the logger, otherwise it returns <c>null</c>.
+            </para>
+            </remarks>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>The logger found, or <c>null</c> if no logger could be found.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers">
+            <overloads>Get the currently defined loggers.</overloads>
+            <summary>
+            Returns all the currently defined loggers in the default repository.
+            </summary>
+            <remarks>
+            <para>The root logger is <b>not</b> included in the returned array.</para>
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String)">
+            <overloads>Get or create a logger.</overloads>
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieves a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.String,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the specified repository) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger found, or <c>null</c> if the logger doesn't exist in the specified 
+            repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">
+            <summary>
+            Returns the named logger if it exists.
+            </summary>
+            <remarks>
+            <para>
+            If the named logger exists (in the repository for the specified assembly) then it
+            returns a reference to the logger, otherwise it returns
+            <c>null</c>.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The fully qualified logger name to look for.</param>
+            <returns>
+            The logger, or <c>null</c> if the logger doesn't exist in the specified
+            assembly's repository.
+            </returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">
+            <summary>
+            Returns all the currently defined loggers in the specified repository.
+            </summary>
+            <param name="repository">The repository to lookup in.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">
+            <summary>
+            Returns all the currently defined loggers in the specified assembly's repository.
+            </summary>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <remarks>
+            The root logger is <b>not</b> included in the returned array.
+            </remarks>
+            <returns>All the defined loggers.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">
+            <summary>
+            Retrieves or creates a named logger.
+            </summary>
+            <remarks>
+            <para>
+            Retrieve a logger named as the <paramref name="name"/>
+            parameter. If the named logger already exists, then the
+            existing instance will be returned. Otherwise, a new instance is
+            created.
+            </para>
+            <para>
+            By default, loggers do not have a set level but inherit
+            it from the hierarchy. This is one of the central features of
+            log4net.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="name">The name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Get the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.
+            </summary>
+            <remarks>
+            Gets the logger for the fully qualified name of the type specified.
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>
+            <returns>The logger with the name specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Shutdown">
+            <summary>
+            Shuts down the log4net system.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in all the
+            default repositories.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository">
+            <overloads>Shutdown a logger repository.</overloads>
+            <summary>
+            Shuts down the default repository.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            default repository.
+            </para>
+            <para>Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">
+            <summary>
+            Shuts down the repository for the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            <paramref name="repository"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repository">The repository to shutdown.</param>
+        </member>
+        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">
+            <summary>
+            Shuts down the repository specified.
+            </summary>
+            <remarks>
+            <para>
+            Calling this method will <b>safely</b> close and remove all
+            appenders in all the loggers including root contained in the
+            repository. The repository is looked up using
+            the <paramref name="repositoryAssembly"/> specified.
+            </para>
+            <para>
+            Some appenders need to be closed before the application exists. 
+            Otherwise, pending logging events might be lost.
+            </para>
+            <para>
+            The <c>shutdown</c> method is careful to close nested
+            appenders before closing regular appenders. This is allows
+            configurations where a regular appender is attached to a logger
+            and again to a nested appender.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration">
+            <overloads>Reset the configuration of a repository</overloads>
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Resets all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repository">The repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">
+            <summary>
+            Resets all values contained in this repository instance to their defaults.
+            </summary>
+            <remarks>
+            <para>
+            Reset all values contained in the repository instance to their
+            defaults.  This removes all appenders from all loggers, sets
+            the level of all non-root loggers to <c>null</c>,
+            sets their additivity flag to <c>true</c> and sets the level
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
+            message disabling is set to its default "off" value.
+            </para>		
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository">
+            <overloads>Get the logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository">
+            <overloads>Get a logger repository.</overloads>
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).
+            </para>
+            </remarks>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.String)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repository"/> argument.
+            </para>
+            </remarks>
+            <param name="repository">The repository to lookup in.</param>
+        </member>
+        <member name="M:log4net.LogManager.GetRepository(System.Reflection.Assembly)">
+            <summary>
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
+            </summary>
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>
+            <remarks>
+            <para>
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified
+            by the <paramref name="repositoryAssembly"/> argument.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Type)">
+            <overloads>Create a domain</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Type)">
+            <overloads>Create a logger repository.</overloads>
+            <summary>
+            Creates a repository with the specified repository type.
+            </summary>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository()"/> will return 
+            the same repository instance.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String)">
+            <summary>
+            Creates a repository with the specified name.
+            </summary>
+            <remarks>
+            <para>
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.String,System.Type)">
+            <summary>
+            Creates a repository with the specified name and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.
+            </para>
+            </remarks>
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>
+        </member>
+        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>
+            </para>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.CreateRepository(System.Reflection.Assembly,System.Type)">
+            <summary>
+            Creates a repository for the specified assembly and repository type.
+            </summary>
+            <remarks>
+            <para>
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the
+            same assembly specified will return the same repository instance.
+            </para>
+            </remarks>
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
+            and has a no arg constructor. An instance of this type will be created to act
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>
+        </member>
+        <member name="M:log4net.LogManager.GetAllRepositories">
+            <summary>
+            Gets the list of currently defined repositories.
+            </summary>
+            <remarks>
+            <para>
+            Get an array of all the <see cref="T:log4net.Repository.ILoggerRepository"/> objects that have been created.
+            </para>
+            </remarks>
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>
+        </member>
+        <member name="M:log4net.LogManager.Flush(System.Int32)">
+            <summary>
+            Flushes logging events buffered in all configured appenders in the default repository.
+            </summary>
+            <param name="millisecondsTimeout">The maximum time in milliseconds to wait for logging events from asycnhronous appenders to be flushed.</param>
+            <returns><c>True</c> if all logging events were flushed successfully, else <c>false</c>.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLogger(log4net.Core.ILogger)">
+            <summary>
+            Looks up the wrapper object for the logger specified.
+            </summary>
+            <param name="logger">The logger to get the wrapper for.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapLoggers(log4net.Core.ILogger[])">
+            <summary>
+            Looks up the wrapper objects for the loggers specified.
+            </summary>
+            <param name="loggers">The loggers to get the wrappers for.</param>
+            <returns>The wrapper objects for the loggers specified.</returns>
+        </member>
+        <member name="M:log4net.LogManager.WrapperCreationHandler(log4net.Core.ILogger)">
+            <summary>
+            Create the <see cref="T:log4net.Core.ILoggerWrapper"/> objects used by
+            this manager.
+            </summary>
+            <param name="logger">The logger to wrap.</param>
+            <returns>The wrapper for the logger specified.</returns>
+        </member>
+        <member name="F:log4net.LogManager.s_wrapperMap">
+            <summary>
+            The wrapper map to use to hold the <see cref="T:log4net.Core.LogImpl"/> objects.
+            </summary>
+        </member>
+        <member name="T:log4net.MDC">
+            <summary>
+            Implementation of Mapped Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is
+            based on a map instead of a stack. It provides <i>mapped
+            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or
+            MDC in short, is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The MDC is managed on a per thread basis.
+            </para>
+            </remarks>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.MDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.MDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Get(System.String)">
+            <summary>
+            Gets the context value identified by the <paramref name="key"/> parameter.
+            </summary>
+            <param name="key">The key to lookup in the MDC.</param>
+            <returns>The string value held for the key, or a <c>null</c> reference if no corresponding value is found.</returns>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            If the <paramref name="key"/> parameter does not look up to a
+            previously defined context then <c>null</c> will be returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Set(System.String,System.String)">
+            <summary>
+            Add an entry to the MDC
+            </summary>
+            <param name="key">The key to store the value under.</param>
+            <param name="value">The value to store.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Puts a context value (the <paramref name="value"/> parameter) as identified
+            with the <paramref name="key"/> parameter into the current thread's
+            context map.
+            </para>
+            <para>
+            If a value is already defined for the <paramref name="key"/>
+            specified then the value will be replaced. If the <paramref name="value"/> 
+            is specified as <c>null</c> then the key value mapping will be removed.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Remove(System.String)">
+            <summary>
+            Removes the key value mapping for the key specified.
+            </summary>
+            <param name="key">The key to remove.</param>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove the specified entry from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.MDC.Clear">
+            <summary>
+            Clear all entries in the MDC
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.
+            </para>
+            </note>
+            <para>
+            Remove all the entries from this thread's MDC
+            </para>
+            </remarks>
+        </member>
+        <member name="T:log4net.NDC">
+            <summary>
+            Implementation of Nested Diagnostic Contexts.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            A Nested Diagnostic Context, or NDC in short, is an instrument
+            to distinguish interleaved log output from different sources. Log
+            output is typically interleaved when a server handles multiple
+            clients near-simultaneously.
+            </para>
+            <para>
+            Interleaved log output can still be meaningful if each log entry
+            from different contexts had a distinctive stamp. This is where NDCs
+            come into play.
+            </para>
+            <para>
+            Note that NDCs are managed on a per thread basis. The NDC class
+            is made up of static methods that operate on the context of the
+            calling thread.
+            </para>
+            </remarks>
+            <example>How to push a message into the context
+            <code lang="C#">
+            using(NDC.Push("my context message"))
+            {
+            	... all log calls will have 'my context message' included ...
+            
+            } // at the end of the using block the message is automatically removed 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+            <author>Gert Driesen</author>
+        </member>
+        <member name="M:log4net.NDC.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:log4net.NDC"/> class. 
+            </summary>
+            <remarks>
+            Uses a private access modifier to prevent instantiation of this class.
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Clear">
+            <summary>
+            Clears all the contextual information held on the current thread.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Clears the stack of NDC data held on the current thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.CloneStack">
+            <summary>
+            Creates a clone of the stack of context information.
+            </summary>
+            <returns>A clone of the context info for this thread.</returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The results of this method can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> 
+            method to allow child threads to inherit the context of their 
+            parent thread.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">
+            <summary>
+            Inherits the contextual information from another thread.
+            </summary>
+            <param name="stack">The context stack to inherit.</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This thread will use the context information from the stack
+            supplied. This can be used to initialize child threads with
+            the same contextual information as their parent threads. These
+            contexts will <b>NOT</b> be shared. Any further contexts that
+            are pushed onto the stack will not be visible to the other.
+            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to
+            this method.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Pop">
+            <summary>
+            Removes the top context from the stack.
+            </summary>
+            <returns>
+            The message in the context that was removed from the top 
+            of the stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Remove the top context from the stack, and return
+            it to the caller. If the stack is empty then an
+            empty string (not <c>null</c>) is returned.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.Push(System.String)">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="message">The new context message.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            using(log4net.NDC.Push("NDC_Message"))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.PushFormat(System.String,System.Object[])">
+            <summary>
+            Pushes a new context message.
+            </summary>
+            <param name="messageFormat">The new context message string format.</param>
+            <param name="args">Arguments to be passed into messageFormat.</param>
+            <returns>
+            An <see cref="T:System.IDisposable"/> that can be used to clean up 
+            the context stack.
+            </returns>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>
+            is returned that can be used to clean up the context stack. This
+            can be easily combined with the <c>using</c> keyword to scope the
+            context.
+            </para>
+            </remarks>
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
+            <code lang="C#">
+            var someValue = "ExampleContext"
+            using(log4net.NDC.PushFormat("NDC_Message {0}", someValue))
+            {
+            	log.Warn("This should have an NDC message");
+            }
+            </code>
+            </example>
+        </member>
+        <member name="M:log4net.NDC.Remove">
+            <summary>
+            Removes the context information for this thread. It is
+            not required to call this method.
+            </summary>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            This method is not implemented.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">
+            <summary>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            </summary>
+            <param name="maxDepth">The maximum depth of the stack</param>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.
+            This may truncate the head of the stack. This only affects the 
+            stack in the current thread. Also it does not prevent it from
+            growing, it only sets the maximum depth at the time of the
+            call. This can be used to return to a known context depth.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.NDC.Depth">
+            <summary>
+            Gets the current context depth.
+            </summary>
+            <value>The current context depth.</value>
+            <remarks>
+            <note>
+            <para>
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.
+            </para>
+            </note>
+            <para>
+            The number of context values pushed onto the context stack.
+            </para>
+            <para>
+            Used to record the current depth of the context. This can then 
+            be restored using the <see cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/> method.
+            </para>
+            </remarks>
+            <seealso cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/>
+        </member>
+        <member name="T:log4net.ThreadContext">
+            <summary>
+            The log4net Thread Context.
+            </summary>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> provides a location for thread specific debugging 
+            information to be stored.
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            <para>
+            The thread context has a properties map and a stack.
+            The properties and stack can 
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>
+            supports selecting and outputting these properties.
+            </para>
+            <para>
+            The Thread Context provides a diagnostic context for the current thread. 
+            This is an instrument for distinguishing interleaved log
+            output from different sources. Log output is typically interleaved
+            when a server handles multiple clients near-simultaneously.
+            </para>
+            <para>
+            The Thread Context is managed on a per thread basis.
+            </para>
+            </remarks>
+            <example>Example of using the thread context properties to store a username.
+            <code lang="C#">
+            ThreadContext.Properties["user"] = userName;
+            log.Info("This log message has a ThreadContext Property called 'user'");
+            </code>
+            </example>
+            <example>Example of how to push a message into the context stack
+            <code lang="C#">
+            using(ThreadContext.Stacks["NDC"].Push("my context message"))
+            {
+            	log.Info("This log message has a ThreadContext Stack message that includes 'my context message'");
+            
+            } // at the end of the using block the message is automatically popped 
+            </code>
+            </example>
+            <threadsafety static="true" instance="true"/>
+            <author>Nicko Cadell</author>
+        </member>
+        <member name="M:log4net.ThreadContext.#ctor">
+            <summary>
+            Private Constructor. 
+            </summary>
+            <remarks>
+            <para>
+            Uses a private access modifier to prevent instantiation of this class.
+            </para>
+            </remarks>
+        </member>
+        <member name="F:log4net.ThreadContext.s_properties">
+            <summary>
+            The thread context properties instance
+            </summary>
+        </member>
+        <member name="F:log4net.ThreadContext.s_stacks">
+            <summary>
+            The thread context stacks instance
+            </summary>
+        </member>
+        <member name="P:log4net.ThreadContext.Properties">
+            <summary>
+            The thread properties map
+            </summary>
+            <value>
+            The thread properties map
+            </value>
+            <remarks>
+            <para>
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>
+            properties with the same name.
+            </para>
+            </remarks>
+        </member>
+        <member name="P:log4net.ThreadContext.Stacks">
+            <summary>
+            The thread stacks
+            </summary>
+            <value>
+            stack map
+            </value>
+            <remarks>
+            <para>
+            The thread local stacks.
+            </para>
+            </remarks>
+        </member>
+    </members>
+</doc>
diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/lib/netstandard1.3/log4net.dll b/AYA.SlnSynor/packages/log4net.2.0.8/lib/netstandard1.3/log4net.dll
new file mode 100644
index 0000000000000000000000000000000000000000..0a66f9b4d98143eb4020898f6eae38f3cc4ab431
GIT binary patch
literal 221184
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

literal 0
HcmV?d00001

diff --git a/AYA.SlnSynor/packages/log4net.2.0.8/log4net.2.0.8.nupkg b/AYA.SlnSynor/packages/log4net.2.0.8/log4net.2.0.8.nupkg
new file mode 100644
index 0000000000000000000000000000000000000000..fec8e8d6cfe1ee89d361bfda12f55c04be0793f8
GIT binary patch
literal 1750988
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%0DEad&0jW_IoP6pd3`_^K_YI9T{
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%0D?9U0xS<u3JL=XtQ>J=g%k
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%0Dg#h#%gnm)uE5vS7
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%0Dw0f7qf5O6=76nZ*sHE|
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%0DZr{3#Gv)^vy3vcfsY=_@up*?>NH!0B_XN
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%0DMU&{EtTS1m$^<Uy<4@(lb9LCbpoL<lt3&=Dx@
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

literal 0
HcmV?d00001